// Generated from d:\git\shaderlang\shader_parser\shader_parser\u005Cushader.g4 by ANTLR 4.8
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class ushaderParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
		T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 
		T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, 
		T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, 
		T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, 
		T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, 
		T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, 
		T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, 
		T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, 
		T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 
		T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 
		T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 
		T__107=108, T__108=109, T__109=110, T__110=111, BlendFactorAlpha=112, 
		BlendOpEnum=113, StringLiteral=114, Comparator=115, BooleanLiteral=116, 
		FillMode=117, CullMode=118, RootDescriptorType=119, ColorMask_RGBA=120, 
		IntegerLiteral=121, FloatingLiteral=122, ExponentPart=123, DecimalLiteral=124, 
		OctalLiteral=125, HexadecimalLiteral=126, BinaryLiteral=127, Sign=128, 
		ID=129, Whitespace=130, Newline=131, BlockComment=132, LineComment=133, 
		SharpComment=134;
	public static final int
		RULE_shader = 0, RULE_shader_item = 1, RULE_subshader = 2, RULE_subshader_item = 3, 
		RULE_tags = 4, RULE_subshader_blend = 5, RULE_subshader_lod = 6, RULE_subshader_UsePass = 7, 
		RULE_subshader_pass = 8, RULE_cgblock = 9, RULE_cg_struct = 10, RULE_cg_struct_item = 11, 
		RULE_cg_uniform = 12, RULE_cg_func = 13, RULE_cg_func_param = 14, RULE_cg_type = 15, 
		RULE_cg_code_item = 16, RULE_cg_code_block = 17, RULE_cg_code_return = 18, 
		RULE_cg_code_call = 19, RULE_cg_code_vardef = 20, RULE_cg_code_varset = 21, 
		RULE_cg_code_vardefinit = 22, RULE_cg_code_selfop = 23, RULE_cg_expr = 24, 
		RULE_cg_expr_normal = 25, RULE_cg_expr_call = 26, RULE_cg_expr_group = 27, 
		RULE_cg_expr_var = 28, RULE_cg_expr_varinit = 29, RULE_cg_expr_member = 30, 
		RULE_cg_expr_invert = 31, RULE_cg_expr_resultmember = 32, RULE_cg_expr_math = 33, 
		RULE_cg_expr_math_h = 34, RULE_cg_expr_typeinit = 35, RULE_property_block = 36, 
		RULE_property_item = 37, RULE_property_item_header = 38, RULE_property_value = 39, 
		RULE_property_value_tex = 40, RULE_property_type = 41, RULE_property = 42, 
		RULE_property_bool = 43, RULE_property_int = 44, RULE_property_uint = 45, 
		RULE_property_float = 46, RULE_property_double = 47, RULE_property_bool2 = 48, 
		RULE_property_bool3 = 49, RULE_property_bool4 = 50, RULE_property_int2 = 51, 
		RULE_property_int3 = 52, RULE_property_int4 = 53, RULE_property_uint2 = 54, 
		RULE_property_uint3 = 55, RULE_property_uint4 = 56, RULE_property_float2 = 57, 
		RULE_property_float3 = 58, RULE_property_float4 = 59, RULE_property_double2 = 60, 
		RULE_property_double3 = 61, RULE_property_double4 = 62, RULE_property_2D = 63, 
		RULE_property_cube = 64, RULE_property_rgb = 65, RULE_property_rgba = 66, 
		RULE_val_bool = 67, RULE_val_int = 68, RULE_val_uint = 69, RULE_val_float = 70, 
		RULE_val_double = 71, RULE_val_bool2 = 72, RULE_val_bool3 = 73, RULE_val_bool4 = 74, 
		RULE_val_int2 = 75, RULE_val_int3 = 76, RULE_val_int4 = 77, RULE_val_uint2 = 78, 
		RULE_val_uint3 = 79, RULE_val_uint4 = 80, RULE_val_float2 = 81, RULE_val_float3 = 82, 
		RULE_val_float4 = 83, RULE_val_double2 = 84, RULE_val_double3 = 85, RULE_val_double4 = 86, 
		RULE_val_tex2d = 87, RULE_default_texture_2d = 88, RULE_val_texcube = 89, 
		RULE_default_texture_cube = 90, RULE_property_name = 91, RULE_display_name = 92, 
		RULE_root_signature = 93, RULE_root_parameter = 94, RULE_register_index = 95, 
		RULE_shader_register = 96, RULE_register_space = 97, RULE_register_num = 98, 
		RULE_vs = 99, RULE_ps = 100, RULE_pass_statement = 101, RULE_render_state_setup = 102, 
		RULE_fill = 103, RULE_cull = 104, RULE_ztest = 105, RULE_zwrite_off = 106, 
		RULE_blend = 107, RULE_blend_expr = 108, RULE_index = 109, RULE_blend_src_factor_color = 110, 
		RULE_blend_dst_factor_color = 111, RULE_blend_src_factor_alpha = 112, 
		RULE_blend_dst_factor_alpha = 113, RULE_blend_factor = 114, RULE_blend_op = 115, 
		RULE_blend_op_color = 116, RULE_blend_op_alpha = 117, RULE_color_mask = 118, 
		RULE_color_mask_value = 119, RULE_stencil = 120, RULE_stencil_state_setup = 121, 
		RULE_stencil_ref = 122, RULE_stencil_mask_read = 123, RULE_stencil_mask_write = 124, 
		RULE_stencil_compare = 125, RULE_stencil_pass = 126, RULE_stencil_fail = 127, 
		RULE_stencil_zfail = 128, RULE_stencil_op = 129, RULE_queue = 130, RULE_val_queue = 131, 
		RULE_queue_key = 132;
	private static String[] makeRuleNames() {
		return new String[] {
			"shader", "shader_item", "subshader", "subshader_item", "tags", "subshader_blend", 
			"subshader_lod", "subshader_UsePass", "subshader_pass", "cgblock", "cg_struct", 
			"cg_struct_item", "cg_uniform", "cg_func", "cg_func_param", "cg_type", 
			"cg_code_item", "cg_code_block", "cg_code_return", "cg_code_call", "cg_code_vardef", 
			"cg_code_varset", "cg_code_vardefinit", "cg_code_selfop", "cg_expr", 
			"cg_expr_normal", "cg_expr_call", "cg_expr_group", "cg_expr_var", "cg_expr_varinit", 
			"cg_expr_member", "cg_expr_invert", "cg_expr_resultmember", "cg_expr_math", 
			"cg_expr_math_h", "cg_expr_typeinit", "property_block", "property_item", 
			"property_item_header", "property_value", "property_value_tex", "property_type", 
			"property", "property_bool", "property_int", "property_uint", "property_float", 
			"property_double", "property_bool2", "property_bool3", "property_bool4", 
			"property_int2", "property_int3", "property_int4", "property_uint2", 
			"property_uint3", "property_uint4", "property_float2", "property_float3", 
			"property_float4", "property_double2", "property_double3", "property_double4", 
			"property_2D", "property_cube", "property_rgb", "property_rgba", "val_bool", 
			"val_int", "val_uint", "val_float", "val_double", "val_bool2", "val_bool3", 
			"val_bool4", "val_int2", "val_int3", "val_int4", "val_uint2", "val_uint3", 
			"val_uint4", "val_float2", "val_float3", "val_float4", "val_double2", 
			"val_double3", "val_double4", "val_tex2d", "default_texture_2d", "val_texcube", 
			"default_texture_cube", "property_name", "display_name", "root_signature", 
			"root_parameter", "register_index", "shader_register", "register_space", 
			"register_num", "vs", "ps", "pass_statement", "render_state_setup", "fill", 
			"cull", "ztest", "zwrite_off", "blend", "blend_expr", "index", "blend_src_factor_color", 
			"blend_dst_factor_color", "blend_src_factor_alpha", "blend_dst_factor_alpha", 
			"blend_factor", "blend_op", "blend_op_color", "blend_op_alpha", "color_mask", 
			"color_mask_value", "stencil", "stencil_state_setup", "stencil_ref", 
			"stencil_mask_read", "stencil_mask_write", "stencil_compare", "stencil_pass", 
			"stencil_fail", "stencil_zfail", "stencil_op", "queue", "val_queue", 
			"queue_key"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'Shader'", "'{'", "'}'", "'CustomEditor'", "'SubShader'", "'Tags'", 
			"'='", "'Blend'", "'LOD'", "'UsePass'", "'Pass'", "'CGPROGRAM'", "'ENDCG'", 
			"'struct'", "';'", "':'", "'uniform'", "'('", "','", "')'", "'fixed'", 
			"'fixed2'", "'fixed3'", "'fixed4'", "'half'", "'half2'", "'half3'", "'half4'", 
			"'float'", "'float2'", "'float3'", "'float4'", "'sampler2D'", "'return'", 
			"'+='", "'-='", "'*='", "'/='", "'.'", "'-'", "'+'", "'*'", "'/'", "'%'", 
			"'Properties'", "'['", "']'", "'Int'", "'2D'", "'Color'", "'Vector'", 
			"'Float'", "'int'", "'2d'", "'color'", "'vector'", "'Range'", "'range'", 
			"'bool'", "'uint'", "'double'", "'bool2'", "'bool3'", "'bool4'", "'int2'", 
			"'int3'", "'int4'", "'uint2'", "'uint3'", "'uint4'", "'double2'", "'double3'", 
			"'double4'", "'Cube'", "'Color3'", "'Color4'", "'White'", "'Black'", 
			"'Bump'", "'RootSignature'", "'Fill'", "'Cull'", "'ZTest'", "'ZWriteOff'", 
			"'SrcColor'", "'DstColor'", "'OneMinusSrcColor'", "'OneMinusDstColor'", 
			"'BlendOp'", "'ColorMask'", "'Stencil'", "'Ref'", "'ReadMask'", "'WriteMask'", 
			"'Comp'", "'Fail'", "'ZFail'", "'Keep'", "'Zero'", "'Replace'", "'IncrSat'", 
			"'DecrSat'", "'Invert'", "'IncrWrap'", "'DecrWarp'", "'Queue'", "'Background'", 
			"'Geometry'", "'AlphaTest'", "'Transparent'", "'Overlay'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, "BlendFactorAlpha", "BlendOpEnum", "StringLiteral", 
			"Comparator", "BooleanLiteral", "FillMode", "CullMode", "RootDescriptorType", 
			"ColorMask_RGBA", "IntegerLiteral", "FloatingLiteral", "ExponentPart", 
			"DecimalLiteral", "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", 
			"Sign", "ID", "Whitespace", "Newline", "BlockComment", "LineComment", 
			"SharpComment"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "ushader.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public ushaderParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class ShaderContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public TerminalNode EOF() { return getToken(ushaderParser.EOF, 0); }
		public List<Shader_itemContext> shader_item() {
			return getRuleContexts(Shader_itemContext.class);
		}
		public Shader_itemContext shader_item(int i) {
			return getRuleContext(Shader_itemContext.class,i);
		}
		public ShaderContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shader; }
	}

	public final ShaderContext shader() throws RecognitionException {
		ShaderContext _localctx = new ShaderContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_shader);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(266);
			match(T__0);
			setState(267);
			match(StringLiteral);
			setState(268);
			match(T__1);
			setState(272);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__4) | (1L << T__44))) != 0)) {
				{
				{
				setState(269);
				shader_item();
				}
				}
				setState(274);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(275);
			match(T__2);
			setState(276);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Shader_itemContext extends ParserRuleContext {
		public Property_blockContext property_block() {
			return getRuleContext(Property_blockContext.class,0);
		}
		public SubshaderContext subshader() {
			return getRuleContext(SubshaderContext.class,0);
		}
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Shader_itemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shader_item; }
	}

	public final Shader_itemContext shader_item() throws RecognitionException {
		Shader_itemContext _localctx = new Shader_itemContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_shader_item);
		try {
			setState(282);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__44:
				enterOuterAlt(_localctx, 1);
				{
				setState(278);
				property_block();
				}
				break;
			case T__4:
				enterOuterAlt(_localctx, 2);
				{
				setState(279);
				subshader();
				}
				break;
			case T__3:
				enterOuterAlt(_localctx, 3);
				{
				{
				setState(280);
				match(T__3);
				setState(281);
				match(StringLiteral);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubshaderContext extends ParserRuleContext {
		public List<Subshader_itemContext> subshader_item() {
			return getRuleContexts(Subshader_itemContext.class);
		}
		public Subshader_itemContext subshader_item(int i) {
			return getRuleContext(Subshader_itemContext.class,i);
		}
		public SubshaderContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subshader; }
	}

	public final SubshaderContext subshader() throws RecognitionException {
		SubshaderContext _localctx = new SubshaderContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_subshader);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(284);
			match(T__4);
			setState(285);
			match(T__1);
			setState(289);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10))) != 0)) {
				{
				{
				setState(286);
				subshader_item();
				}
				}
				setState(291);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(292);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Subshader_itemContext extends ParserRuleContext {
		public Subshader_passContext subshader_pass() {
			return getRuleContext(Subshader_passContext.class,0);
		}
		public TagsContext tags() {
			return getRuleContext(TagsContext.class,0);
		}
		public Subshader_blendContext subshader_blend() {
			return getRuleContext(Subshader_blendContext.class,0);
		}
		public Subshader_lodContext subshader_lod() {
			return getRuleContext(Subshader_lodContext.class,0);
		}
		public Subshader_UsePassContext subshader_UsePass() {
			return getRuleContext(Subshader_UsePassContext.class,0);
		}
		public Subshader_itemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subshader_item; }
	}

	public final Subshader_itemContext subshader_item() throws RecognitionException {
		Subshader_itemContext _localctx = new Subshader_itemContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_subshader_item);
		try {
			setState(299);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__10:
				enterOuterAlt(_localctx, 1);
				{
				setState(294);
				subshader_pass();
				}
				break;
			case T__5:
				enterOuterAlt(_localctx, 2);
				{
				setState(295);
				tags();
				}
				break;
			case T__7:
				enterOuterAlt(_localctx, 3);
				{
				setState(296);
				subshader_blend();
				}
				break;
			case T__8:
				enterOuterAlt(_localctx, 4);
				{
				setState(297);
				subshader_lod();
				}
				break;
			case T__9:
				enterOuterAlt(_localctx, 5);
				{
				setState(298);
				subshader_UsePass();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TagsContext extends ParserRuleContext {
		public List<TerminalNode> StringLiteral() { return getTokens(ushaderParser.StringLiteral); }
		public TerminalNode StringLiteral(int i) {
			return getToken(ushaderParser.StringLiteral, i);
		}
		public TagsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tags; }
	}

	public final TagsContext tags() throws RecognitionException {
		TagsContext _localctx = new TagsContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_tags);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(301);
			match(T__5);
			setState(302);
			match(T__1);
			setState(308);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==StringLiteral) {
				{
				{
				setState(303);
				match(StringLiteral);
				setState(304);
				match(T__6);
				setState(305);
				match(StringLiteral);
				}
				}
				setState(310);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(311);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Subshader_blendContext extends ParserRuleContext {
		public List<Blend_factorContext> blend_factor() {
			return getRuleContexts(Blend_factorContext.class);
		}
		public Blend_factorContext blend_factor(int i) {
			return getRuleContext(Blend_factorContext.class,i);
		}
		public Subshader_blendContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subshader_blend; }
	}

	public final Subshader_blendContext subshader_blend() throws RecognitionException {
		Subshader_blendContext _localctx = new Subshader_blendContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_subshader_blend);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(313);
			match(T__7);
			setState(314);
			blend_factor();
			setState(315);
			blend_factor();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Subshader_lodContext extends ParserRuleContext {
		public Val_intContext val_int() {
			return getRuleContext(Val_intContext.class,0);
		}
		public Subshader_lodContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subshader_lod; }
	}

	public final Subshader_lodContext subshader_lod() throws RecognitionException {
		Subshader_lodContext _localctx = new Subshader_lodContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_subshader_lod);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(317);
			match(T__8);
			setState(318);
			val_int();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Subshader_UsePassContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Subshader_UsePassContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subshader_UsePass; }
	}

	public final Subshader_UsePassContext subshader_UsePass() throws RecognitionException {
		Subshader_UsePassContext _localctx = new Subshader_UsePassContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_subshader_UsePass);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(320);
			match(T__9);
			setState(321);
			match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Subshader_passContext extends ParserRuleContext {
		public List<Pass_statementContext> pass_statement() {
			return getRuleContexts(Pass_statementContext.class);
		}
		public Pass_statementContext pass_statement(int i) {
			return getRuleContext(Pass_statementContext.class,i);
		}
		public List<CgblockContext> cgblock() {
			return getRuleContexts(CgblockContext.class);
		}
		public CgblockContext cgblock(int i) {
			return getRuleContext(CgblockContext.class,i);
		}
		public Subshader_passContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subshader_pass; }
	}

	public final Subshader_passContext subshader_pass() throws RecognitionException {
		Subshader_passContext _localctx = new Subshader_passContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_subshader_pass);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(323);
			match(T__10);
			setState(324);
			match(T__1);
			setState(328);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__5 || _la==T__7 || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & ((1L << (T__80 - 81)) | (1L << (T__81 - 81)) | (1L << (T__82 - 81)) | (1L << (T__83 - 81)) | (1L << (T__88 - 81)) | (1L << (T__89 - 81)) | (1L << (T__90 - 81)) | (1L << (T__105 - 81)))) != 0)) {
				{
				{
				setState(325);
				pass_statement();
				}
				}
				setState(330);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(334);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__11) {
				{
				{
				setState(331);
				cgblock();
				}
				}
				setState(336);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(337);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CgblockContext extends ParserRuleContext {
		public List<TerminalNode> SharpComment() { return getTokens(ushaderParser.SharpComment); }
		public TerminalNode SharpComment(int i) {
			return getToken(ushaderParser.SharpComment, i);
		}
		public List<Cg_funcContext> cg_func() {
			return getRuleContexts(Cg_funcContext.class);
		}
		public Cg_funcContext cg_func(int i) {
			return getRuleContext(Cg_funcContext.class,i);
		}
		public List<Cg_uniformContext> cg_uniform() {
			return getRuleContexts(Cg_uniformContext.class);
		}
		public Cg_uniformContext cg_uniform(int i) {
			return getRuleContext(Cg_uniformContext.class,i);
		}
		public List<Cg_structContext> cg_struct() {
			return getRuleContexts(Cg_structContext.class);
		}
		public Cg_structContext cg_struct(int i) {
			return getRuleContext(Cg_structContext.class,i);
		}
		public CgblockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cgblock; }
	}

	public final CgblockContext cgblock() throws RecognitionException {
		CgblockContext _localctx = new CgblockContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_cgblock);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(339);
			match(T__11);
			setState(346);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__13) | (1L << T__16) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32))) != 0) || _la==ID || _la==SharpComment) {
				{
				setState(344);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case SharpComment:
					{
					setState(340);
					match(SharpComment);
					}
					break;
				case T__20:
				case T__21:
				case T__22:
				case T__23:
				case T__24:
				case T__25:
				case T__26:
				case T__27:
				case T__28:
				case T__29:
				case T__30:
				case T__31:
				case T__32:
				case ID:
					{
					setState(341);
					cg_func();
					}
					break;
				case T__16:
					{
					setState(342);
					cg_uniform();
					}
					break;
				case T__13:
					{
					setState(343);
					cg_struct();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(348);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(349);
			match(T__12);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_structContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public List<Cg_struct_itemContext> cg_struct_item() {
			return getRuleContexts(Cg_struct_itemContext.class);
		}
		public Cg_struct_itemContext cg_struct_item(int i) {
			return getRuleContext(Cg_struct_itemContext.class,i);
		}
		public Cg_structContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_struct; }
	}

	public final Cg_structContext cg_struct() throws RecognitionException {
		Cg_structContext _localctx = new Cg_structContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_cg_struct);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(351);
			match(T__13);
			setState(352);
			match(ID);
			setState(353);
			match(T__1);
			setState(357);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32))) != 0) || _la==ID || _la==SharpComment) {
				{
				{
				setState(354);
				cg_struct_item();
				}
				}
				setState(359);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(360);
			match(T__2);
			setState(362);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__14) {
				{
				setState(361);
				match(T__14);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_struct_itemContext extends ParserRuleContext {
		public TerminalNode SharpComment() { return getToken(ushaderParser.SharpComment, 0); }
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public List<TerminalNode> ID() { return getTokens(ushaderParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(ushaderParser.ID, i);
		}
		public Cg_struct_itemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_struct_item; }
	}

	public final Cg_struct_itemContext cg_struct_item() throws RecognitionException {
		Cg_struct_itemContext _localctx = new Cg_struct_itemContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_cg_struct_item);
		try {
			setState(371);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SharpComment:
				enterOuterAlt(_localctx, 1);
				{
				setState(364);
				match(SharpComment);
				}
				break;
			case T__20:
			case T__21:
			case T__22:
			case T__23:
			case T__24:
			case T__25:
			case T__26:
			case T__27:
			case T__28:
			case T__29:
			case T__30:
			case T__31:
			case T__32:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(365);
				cg_type();
				setState(366);
				match(ID);
				setState(367);
				match(T__15);
				setState(368);
				match(ID);
				setState(369);
				match(T__14);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_uniformContext extends ParserRuleContext {
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public Cg_uniformContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_uniform; }
	}

	public final Cg_uniformContext cg_uniform() throws RecognitionException {
		Cg_uniformContext _localctx = new Cg_uniformContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_cg_uniform);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(373);
			match(T__16);
			setState(374);
			cg_type();
			setState(375);
			match(ID);
			setState(376);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_funcContext extends ParserRuleContext {
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public List<TerminalNode> ID() { return getTokens(ushaderParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(ushaderParser.ID, i);
		}
		public List<Cg_func_paramContext> cg_func_param() {
			return getRuleContexts(Cg_func_paramContext.class);
		}
		public Cg_func_paramContext cg_func_param(int i) {
			return getRuleContext(Cg_func_paramContext.class,i);
		}
		public List<Cg_code_itemContext> cg_code_item() {
			return getRuleContexts(Cg_code_itemContext.class);
		}
		public Cg_code_itemContext cg_code_item(int i) {
			return getRuleContext(Cg_code_itemContext.class,i);
		}
		public Cg_funcContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_func; }
	}

	public final Cg_funcContext cg_func() throws RecognitionException {
		Cg_funcContext _localctx = new Cg_funcContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_cg_func);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(378);
			cg_type();
			setState(379);
			match(ID);
			setState(380);
			match(T__17);
			setState(389);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32))) != 0) || _la==ID) {
				{
				setState(381);
				cg_func_param();
				setState(386);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__18) {
					{
					{
					setState(382);
					match(T__18);
					setState(383);
					cg_func_param();
					}
					}
					setState(388);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(391);
			match(T__19);
			setState(394);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__15) {
				{
				setState(392);
				match(T__15);
				setState(393);
				match(ID);
				}
			}

			setState(396);
			match(T__1);
			setState(400);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__17) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__39))) != 0) || ((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & ((1L << (IntegerLiteral - 121)) | (1L << (FloatingLiteral - 121)) | (1L << (ID - 121)) | (1L << (SharpComment - 121)))) != 0)) {
				{
				{
				setState(397);
				cg_code_item();
				}
				}
				setState(402);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(403);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_func_paramContext extends ParserRuleContext {
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public List<TerminalNode> ID() { return getTokens(ushaderParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(ushaderParser.ID, i);
		}
		public Cg_func_paramContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_func_param; }
	}

	public final Cg_func_paramContext cg_func_param() throws RecognitionException {
		Cg_func_paramContext _localctx = new Cg_func_paramContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_cg_func_param);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(405);
			cg_type();
			setState(406);
			match(ID);
			setState(409);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__15) {
				{
				setState(407);
				match(T__15);
				setState(408);
				match(ID);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_typeContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public Cg_typeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_type; }
	}

	public final Cg_typeContext cg_type() throws RecognitionException {
		Cg_typeContext _localctx = new Cg_typeContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_cg_type);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(411);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32))) != 0) || _la==ID) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_itemContext extends ParserRuleContext {
		public TerminalNode SharpComment() { return getToken(ushaderParser.SharpComment, 0); }
		public Cg_code_blockContext cg_code_block() {
			return getRuleContext(Cg_code_blockContext.class,0);
		}
		public Cg_code_returnContext cg_code_return() {
			return getRuleContext(Cg_code_returnContext.class,0);
		}
		public Cg_code_vardefContext cg_code_vardef() {
			return getRuleContext(Cg_code_vardefContext.class,0);
		}
		public Cg_code_varsetContext cg_code_varset() {
			return getRuleContext(Cg_code_varsetContext.class,0);
		}
		public Cg_code_vardefinitContext cg_code_vardefinit() {
			return getRuleContext(Cg_code_vardefinitContext.class,0);
		}
		public Cg_code_callContext cg_code_call() {
			return getRuleContext(Cg_code_callContext.class,0);
		}
		public Cg_code_selfopContext cg_code_selfop() {
			return getRuleContext(Cg_code_selfopContext.class,0);
		}
		public Cg_code_itemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_item; }
	}

	public final Cg_code_itemContext cg_code_item() throws RecognitionException {
		Cg_code_itemContext _localctx = new Cg_code_itemContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_cg_code_item);
		try {
			setState(421);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(413);
				match(SharpComment);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(414);
				cg_code_block();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(415);
				cg_code_return();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(416);
				cg_code_vardef();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(417);
				cg_code_varset();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(418);
				cg_code_vardefinit();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(419);
				cg_code_call();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(420);
				cg_code_selfop();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_blockContext extends ParserRuleContext {
		public List<Cg_code_itemContext> cg_code_item() {
			return getRuleContexts(Cg_code_itemContext.class);
		}
		public Cg_code_itemContext cg_code_item(int i) {
			return getRuleContext(Cg_code_itemContext.class,i);
		}
		public Cg_code_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_block; }
	}

	public final Cg_code_blockContext cg_code_block() throws RecognitionException {
		Cg_code_blockContext _localctx = new Cg_code_blockContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_cg_code_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(423);
			match(T__1);
			setState(427);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__17) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__39))) != 0) || ((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & ((1L << (IntegerLiteral - 121)) | (1L << (FloatingLiteral - 121)) | (1L << (ID - 121)) | (1L << (SharpComment - 121)))) != 0)) {
				{
				{
				setState(424);
				cg_code_item();
				}
				}
				setState(429);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(430);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_returnContext extends ParserRuleContext {
		public Cg_exprContext cg_expr() {
			return getRuleContext(Cg_exprContext.class,0);
		}
		public Cg_code_returnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_return; }
	}

	public final Cg_code_returnContext cg_code_return() throws RecognitionException {
		Cg_code_returnContext _localctx = new Cg_code_returnContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_cg_code_return);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(432);
			match(T__33);
			setState(433);
			cg_expr();
			setState(434);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_callContext extends ParserRuleContext {
		public Cg_expr_callContext cg_expr_call() {
			return getRuleContext(Cg_expr_callContext.class,0);
		}
		public Cg_code_callContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_call; }
	}

	public final Cg_code_callContext cg_code_call() throws RecognitionException {
		Cg_code_callContext _localctx = new Cg_code_callContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_cg_code_call);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(436);
			cg_expr_call();
			setState(437);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_vardefContext extends ParserRuleContext {
		public List<TerminalNode> ID() { return getTokens(ushaderParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(ushaderParser.ID, i);
		}
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public Cg_code_vardefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_vardef; }
	}

	public final Cg_code_vardefContext cg_code_vardef() throws RecognitionException {
		Cg_code_vardefContext _localctx = new Cg_code_vardefContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_cg_code_vardef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(441);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				{
				setState(439);
				match(ID);
				}
				break;
			case 2:
				{
				setState(440);
				cg_type();
				}
				break;
			}
			setState(443);
			match(ID);
			setState(444);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_varsetContext extends ParserRuleContext {
		public List<Cg_exprContext> cg_expr() {
			return getRuleContexts(Cg_exprContext.class);
		}
		public Cg_exprContext cg_expr(int i) {
			return getRuleContext(Cg_exprContext.class,i);
		}
		public Cg_code_varsetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_varset; }
	}

	public final Cg_code_varsetContext cg_code_varset() throws RecognitionException {
		Cg_code_varsetContext _localctx = new Cg_code_varsetContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_cg_code_varset);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(446);
			cg_expr();
			setState(447);
			match(T__6);
			setState(448);
			cg_expr();
			setState(449);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_vardefinitContext extends ParserRuleContext {
		public List<TerminalNode> ID() { return getTokens(ushaderParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(ushaderParser.ID, i);
		}
		public Cg_exprContext cg_expr() {
			return getRuleContext(Cg_exprContext.class,0);
		}
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public Cg_code_vardefinitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_vardefinit; }
	}

	public final Cg_code_vardefinitContext cg_code_vardefinit() throws RecognitionException {
		Cg_code_vardefinitContext _localctx = new Cg_code_vardefinitContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_cg_code_vardefinit);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(453);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
			case 1:
				{
				setState(451);
				match(ID);
				}
				break;
			case 2:
				{
				setState(452);
				cg_type();
				}
				break;
			}
			setState(455);
			match(ID);
			setState(456);
			match(T__6);
			setState(457);
			cg_expr();
			setState(458);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_code_selfopContext extends ParserRuleContext {
		public List<Cg_exprContext> cg_expr() {
			return getRuleContexts(Cg_exprContext.class);
		}
		public Cg_exprContext cg_expr(int i) {
			return getRuleContext(Cg_exprContext.class,i);
		}
		public Cg_code_selfopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_code_selfop; }
	}

	public final Cg_code_selfopContext cg_code_selfop() throws RecognitionException {
		Cg_code_selfopContext _localctx = new Cg_code_selfopContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_cg_code_selfop);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(460);
			cg_expr();
			setState(461);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(462);
			cg_expr();
			setState(463);
			match(T__14);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_exprContext extends ParserRuleContext {
		public Cg_expr_mathContext cg_expr_math() {
			return getRuleContext(Cg_expr_mathContext.class,0);
		}
		public Cg_expr_math_hContext cg_expr_math_h() {
			return getRuleContext(Cg_expr_math_hContext.class,0);
		}
		public Cg_expr_normalContext cg_expr_normal() {
			return getRuleContext(Cg_expr_normalContext.class,0);
		}
		public Cg_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr; }
	}

	public final Cg_exprContext cg_expr() throws RecognitionException {
		Cg_exprContext _localctx = new Cg_exprContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_cg_expr);
		try {
			setState(468);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(465);
				cg_expr_math();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(466);
				cg_expr_math_h();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(467);
				cg_expr_normal();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_normalContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public Cg_expr_invertContext cg_expr_invert() {
			return getRuleContext(Cg_expr_invertContext.class,0);
		}
		public Cg_expr_groupContext cg_expr_group() {
			return getRuleContext(Cg_expr_groupContext.class,0);
		}
		public Cg_expr_varContext cg_expr_var() {
			return getRuleContext(Cg_expr_varContext.class,0);
		}
		public Cg_expr_varinitContext cg_expr_varinit() {
			return getRuleContext(Cg_expr_varinitContext.class,0);
		}
		public Cg_expr_callContext cg_expr_call() {
			return getRuleContext(Cg_expr_callContext.class,0);
		}
		public Cg_expr_memberContext cg_expr_member() {
			return getRuleContext(Cg_expr_memberContext.class,0);
		}
		public Cg_expr_resultmemberContext cg_expr_resultmember() {
			return getRuleContext(Cg_expr_resultmemberContext.class,0);
		}
		public Cg_expr_typeinitContext cg_expr_typeinit() {
			return getRuleContext(Cg_expr_typeinitContext.class,0);
		}
		public Cg_expr_normalContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_normal; }
	}

	public final Cg_expr_normalContext cg_expr_normal() throws RecognitionException {
		Cg_expr_normalContext _localctx = new Cg_expr_normalContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_cg_expr_normal);
		try {
			setState(479);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(470);
				match(ID);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(471);
				cg_expr_invert();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(472);
				cg_expr_group();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(473);
				cg_expr_var();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(474);
				cg_expr_varinit();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(475);
				cg_expr_call();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(476);
				cg_expr_member(0);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(477);
				cg_expr_resultmember();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(478);
				cg_expr_typeinit();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_callContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public List<Cg_exprContext> cg_expr() {
			return getRuleContexts(Cg_exprContext.class);
		}
		public Cg_exprContext cg_expr(int i) {
			return getRuleContext(Cg_exprContext.class,i);
		}
		public Cg_expr_callContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_call; }
	}

	public final Cg_expr_callContext cg_expr_call() throws RecognitionException {
		Cg_expr_callContext _localctx = new Cg_expr_callContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_cg_expr_call);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(481);
			match(ID);
			setState(482);
			match(T__17);
			setState(491);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__17) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__39))) != 0) || ((((_la - 121)) & ~0x3f) == 0 && ((1L << (_la - 121)) & ((1L << (IntegerLiteral - 121)) | (1L << (FloatingLiteral - 121)) | (1L << (ID - 121)))) != 0)) {
				{
				setState(483);
				cg_expr();
				setState(488);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__18) {
					{
					{
					setState(484);
					match(T__18);
					setState(485);
					cg_expr();
					}
					}
					setState(490);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(493);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_groupContext extends ParserRuleContext {
		public Cg_exprContext cg_expr() {
			return getRuleContext(Cg_exprContext.class,0);
		}
		public Cg_expr_groupContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_group; }
	}

	public final Cg_expr_groupContext cg_expr_group() throws RecognitionException {
		Cg_expr_groupContext _localctx = new Cg_expr_groupContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_cg_expr_group);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(495);
			match(T__17);
			setState(496);
			cg_expr();
			setState(497);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_varContext extends ParserRuleContext {
		public Val_floatContext val_float() {
			return getRuleContext(Val_floatContext.class,0);
		}
		public Val_float2Context val_float2() {
			return getRuleContext(Val_float2Context.class,0);
		}
		public Val_float3Context val_float3() {
			return getRuleContext(Val_float3Context.class,0);
		}
		public Val_float4Context val_float4() {
			return getRuleContext(Val_float4Context.class,0);
		}
		public Cg_expr_varContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_var; }
	}

	public final Cg_expr_varContext cg_expr_var() throws RecognitionException {
		Cg_expr_varContext _localctx = new Cg_expr_varContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_cg_expr_var);
		try {
			setState(503);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(499);
				val_float();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(500);
				val_float2();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(501);
				val_float3();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(502);
				val_float4();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_varinitContext extends ParserRuleContext {
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public List<Cg_exprContext> cg_expr() {
			return getRuleContexts(Cg_exprContext.class);
		}
		public Cg_exprContext cg_expr(int i) {
			return getRuleContext(Cg_exprContext.class,i);
		}
		public Cg_expr_varinitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_varinit; }
	}

	public final Cg_expr_varinitContext cg_expr_varinit() throws RecognitionException {
		Cg_expr_varinitContext _localctx = new Cg_expr_varinitContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_cg_expr_varinit);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(505);
			cg_type();
			setState(506);
			match(T__17);
			setState(507);
			cg_expr();
			setState(512);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__18) {
				{
				{
				setState(508);
				match(T__18);
				setState(509);
				cg_expr();
				}
				}
				setState(514);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(515);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_memberContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public Cg_expr_memberContext cg_expr_member() {
			return getRuleContext(Cg_expr_memberContext.class,0);
		}
		public Cg_expr_memberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_member; }
	}

	public final Cg_expr_memberContext cg_expr_member() throws RecognitionException {
		return cg_expr_member(0);
	}

	private Cg_expr_memberContext cg_expr_member(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		Cg_expr_memberContext _localctx = new Cg_expr_memberContext(_ctx, _parentState);
		Cg_expr_memberContext _prevctx = _localctx;
		int _startState = 60;
		enterRecursionRule(_localctx, 60, RULE_cg_expr_member, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(518);
			match(ID);
			}
			_ctx.stop = _input.LT(-1);
			setState(525);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new Cg_expr_memberContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_cg_expr_member);
					setState(520);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(521);
					match(T__38);
					setState(522);
					match(ID);
					}
					} 
				}
				setState(527);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class Cg_expr_invertContext extends ParserRuleContext {
		public Cg_exprContext cg_expr() {
			return getRuleContext(Cg_exprContext.class,0);
		}
		public Cg_expr_invertContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_invert; }
	}

	public final Cg_expr_invertContext cg_expr_invert() throws RecognitionException {
		Cg_expr_invertContext _localctx = new Cg_expr_invertContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_cg_expr_invert);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(528);
			match(T__39);
			setState(529);
			cg_expr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_resultmemberContext extends ParserRuleContext {
		public Cg_expr_callContext cg_expr_call() {
			return getRuleContext(Cg_expr_callContext.class,0);
		}
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public Cg_expr_resultmemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_resultmember; }
	}

	public final Cg_expr_resultmemberContext cg_expr_resultmember() throws RecognitionException {
		Cg_expr_resultmemberContext _localctx = new Cg_expr_resultmemberContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_cg_expr_resultmember);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(531);
			cg_expr_call();
			setState(532);
			match(T__38);
			setState(533);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_mathContext extends ParserRuleContext {
		public Cg_exprContext cg_expr() {
			return getRuleContext(Cg_exprContext.class,0);
		}
		public Cg_expr_normalContext cg_expr_normal() {
			return getRuleContext(Cg_expr_normalContext.class,0);
		}
		public Cg_expr_math_hContext cg_expr_math_h() {
			return getRuleContext(Cg_expr_math_hContext.class,0);
		}
		public Cg_expr_mathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_math; }
	}

	public final Cg_expr_mathContext cg_expr_math() throws RecognitionException {
		Cg_expr_mathContext _localctx = new Cg_expr_mathContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_cg_expr_math);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(537);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
			case 1:
				{
				setState(535);
				cg_expr_normal();
				}
				break;
			case 2:
				{
				setState(536);
				cg_expr_math_h();
				}
				break;
			}
			setState(539);
			_la = _input.LA(1);
			if ( !(_la==T__39 || _la==T__40) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(540);
			cg_expr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_math_hContext extends ParserRuleContext {
		public Cg_expr_normalContext cg_expr_normal() {
			return getRuleContext(Cg_expr_normalContext.class,0);
		}
		public Cg_exprContext cg_expr() {
			return getRuleContext(Cg_exprContext.class,0);
		}
		public Cg_expr_math_hContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_math_h; }
	}

	public final Cg_expr_math_hContext cg_expr_math_h() throws RecognitionException {
		Cg_expr_math_hContext _localctx = new Cg_expr_math_hContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_cg_expr_math_h);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(542);
			cg_expr_normal();
			setState(543);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(544);
			cg_expr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cg_expr_typeinitContext extends ParserRuleContext {
		public Cg_typeContext cg_type() {
			return getRuleContext(Cg_typeContext.class,0);
		}
		public Cg_expr_varContext cg_expr_var() {
			return getRuleContext(Cg_expr_varContext.class,0);
		}
		public Cg_expr_typeinitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cg_expr_typeinit; }
	}

	public final Cg_expr_typeinitContext cg_expr_typeinit() throws RecognitionException {
		Cg_expr_typeinitContext _localctx = new Cg_expr_typeinitContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_cg_expr_typeinit);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(546);
			cg_type();
			setState(547);
			cg_expr_var();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_blockContext extends ParserRuleContext {
		public List<Property_itemContext> property_item() {
			return getRuleContexts(Property_itemContext.class);
		}
		public Property_itemContext property_item(int i) {
			return getRuleContext(Property_itemContext.class,i);
		}
		public Property_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_block; }
	}

	public final Property_blockContext property_block() throws RecognitionException {
		Property_blockContext _localctx = new Property_blockContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_property_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(549);
			match(T__44);
			setState(550);
			match(T__1);
			setState(552); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(551);
				property_item();
				}
				}
				setState(554); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==T__45 || _la==ID );
			setState(556);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_itemContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Property_typeContext property_type() {
			return getRuleContext(Property_typeContext.class,0);
		}
		public List<Property_item_headerContext> property_item_header() {
			return getRuleContexts(Property_item_headerContext.class);
		}
		public Property_item_headerContext property_item_header(int i) {
			return getRuleContext(Property_item_headerContext.class,i);
		}
		public Property_valueContext property_value() {
			return getRuleContext(Property_valueContext.class,0);
		}
		public Property_itemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_item; }
	}

	public final Property_itemContext property_item() throws RecognitionException {
		Property_itemContext _localctx = new Property_itemContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_property_item);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(561);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__45) {
				{
				{
				setState(558);
				property_item_header();
				}
				}
				setState(563);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(564);
			match(ID);
			setState(565);
			match(T__17);
			setState(566);
			match(StringLiteral);
			setState(567);
			match(T__18);
			setState(568);
			property_type();
			setState(569);
			match(T__19);
			setState(572);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__6) {
				{
				setState(570);
				match(T__6);
				setState(571);
				property_value();
				}
			}

			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_item_headerContext extends ParserRuleContext {
		public List<TerminalNode> ID() { return getTokens(ushaderParser.ID); }
		public TerminalNode ID(int i) {
			return getToken(ushaderParser.ID, i);
		}
		public Property_item_headerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_item_header; }
	}

	public final Property_item_headerContext property_item_header() throws RecognitionException {
		Property_item_headerContext _localctx = new Property_item_headerContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_property_item_header);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(574);
			match(T__45);
			setState(575);
			match(ID);
			setState(576);
			match(T__17);
			setState(577);
			match(ID);
			setState(578);
			match(T__19);
			setState(579);
			match(T__46);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_valueContext extends ParserRuleContext {
		public Cg_expr_varContext cg_expr_var() {
			return getRuleContext(Cg_expr_varContext.class,0);
		}
		public Property_value_texContext property_value_tex() {
			return getRuleContext(Property_value_texContext.class,0);
		}
		public Property_valueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_value; }
	}

	public final Property_valueContext property_value() throws RecognitionException {
		Property_valueContext _localctx = new Property_valueContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_property_value);
		try {
			setState(583);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__17:
			case T__39:
			case IntegerLiteral:
			case FloatingLiteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(581);
				cg_expr_var();
				}
				break;
			case StringLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(582);
				property_value_tex();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_value_texContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Property_value_texContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_value_tex; }
	}

	public final Property_value_texContext property_value_tex() throws RecognitionException {
		Property_value_texContext _localctx = new Property_value_texContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_property_value_tex);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(585);
			match(StringLiteral);
			setState(586);
			match(T__1);
			setState(587);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_typeContext extends ParserRuleContext {
		public Val_float2Context val_float2() {
			return getRuleContext(Val_float2Context.class,0);
		}
		public Property_typeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_type; }
	}

	public final Property_typeContext property_type() throws RecognitionException {
		Property_typeContext _localctx = new Property_typeContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_property_type);
		int _la;
		try {
			setState(601);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__47:
				enterOuterAlt(_localctx, 1);
				{
				setState(589);
				match(T__47);
				}
				break;
			case T__48:
				enterOuterAlt(_localctx, 2);
				{
				setState(590);
				match(T__48);
				}
				break;
			case T__49:
				enterOuterAlt(_localctx, 3);
				{
				setState(591);
				match(T__49);
				}
				break;
			case T__50:
				enterOuterAlt(_localctx, 4);
				{
				setState(592);
				match(T__50);
				}
				break;
			case T__51:
				enterOuterAlt(_localctx, 5);
				{
				setState(593);
				match(T__51);
				}
				break;
			case T__52:
				enterOuterAlt(_localctx, 6);
				{
				setState(594);
				match(T__52);
				}
				break;
			case T__53:
				enterOuterAlt(_localctx, 7);
				{
				setState(595);
				match(T__53);
				}
				break;
			case T__54:
				enterOuterAlt(_localctx, 8);
				{
				setState(596);
				match(T__54);
				}
				break;
			case T__55:
				enterOuterAlt(_localctx, 9);
				{
				setState(597);
				match(T__55);
				}
				break;
			case T__28:
				enterOuterAlt(_localctx, 10);
				{
				setState(598);
				match(T__28);
				}
				break;
			case T__56:
			case T__57:
				enterOuterAlt(_localctx, 11);
				{
				{
				setState(599);
				_la = _input.LA(1);
				if ( !(_la==T__56 || _la==T__57) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(600);
				val_float2();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PropertyContext extends ParserRuleContext {
		public Property_boolContext property_bool() {
			return getRuleContext(Property_boolContext.class,0);
		}
		public Property_intContext property_int() {
			return getRuleContext(Property_intContext.class,0);
		}
		public Property_uintContext property_uint() {
			return getRuleContext(Property_uintContext.class,0);
		}
		public Property_floatContext property_float() {
			return getRuleContext(Property_floatContext.class,0);
		}
		public Property_doubleContext property_double() {
			return getRuleContext(Property_doubleContext.class,0);
		}
		public Property_bool2Context property_bool2() {
			return getRuleContext(Property_bool2Context.class,0);
		}
		public Property_bool3Context property_bool3() {
			return getRuleContext(Property_bool3Context.class,0);
		}
		public Property_bool4Context property_bool4() {
			return getRuleContext(Property_bool4Context.class,0);
		}
		public Property_int2Context property_int2() {
			return getRuleContext(Property_int2Context.class,0);
		}
		public Property_int3Context property_int3() {
			return getRuleContext(Property_int3Context.class,0);
		}
		public Property_int4Context property_int4() {
			return getRuleContext(Property_int4Context.class,0);
		}
		public Property_uint2Context property_uint2() {
			return getRuleContext(Property_uint2Context.class,0);
		}
		public Property_uint3Context property_uint3() {
			return getRuleContext(Property_uint3Context.class,0);
		}
		public Property_uint4Context property_uint4() {
			return getRuleContext(Property_uint4Context.class,0);
		}
		public Property_float2Context property_float2() {
			return getRuleContext(Property_float2Context.class,0);
		}
		public Property_float3Context property_float3() {
			return getRuleContext(Property_float3Context.class,0);
		}
		public Property_float4Context property_float4() {
			return getRuleContext(Property_float4Context.class,0);
		}
		public Property_double2Context property_double2() {
			return getRuleContext(Property_double2Context.class,0);
		}
		public Property_double3Context property_double3() {
			return getRuleContext(Property_double3Context.class,0);
		}
		public Property_double4Context property_double4() {
			return getRuleContext(Property_double4Context.class,0);
		}
		public Property_2DContext property_2D() {
			return getRuleContext(Property_2DContext.class,0);
		}
		public Property_cubeContext property_cube() {
			return getRuleContext(Property_cubeContext.class,0);
		}
		public Property_rgbContext property_rgb() {
			return getRuleContext(Property_rgbContext.class,0);
		}
		public Property_rgbaContext property_rgba() {
			return getRuleContext(Property_rgbaContext.class,0);
		}
		public PropertyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property; }
	}

	public final PropertyContext property() throws RecognitionException {
		PropertyContext _localctx = new PropertyContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_property);
		try {
			setState(627);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(603);
				property_bool();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(604);
				property_int();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(605);
				property_uint();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(606);
				property_float();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(607);
				property_double();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(608);
				property_bool2();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(609);
				property_bool3();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(610);
				property_bool4();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(611);
				property_int2();
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(612);
				property_int3();
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(613);
				property_int4();
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(614);
				property_uint2();
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(615);
				property_uint3();
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(616);
				property_uint4();
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(617);
				property_float2();
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(618);
				property_float3();
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(619);
				property_float4();
				}
				break;
			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(620);
				property_double2();
				}
				break;
			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(621);
				property_double3();
				}
				break;
			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(622);
				property_double4();
				}
				break;
			case 21:
				enterOuterAlt(_localctx, 21);
				{
				setState(623);
				property_2D();
				}
				break;
			case 22:
				enterOuterAlt(_localctx, 22);
				{
				setState(624);
				property_cube();
				}
				break;
			case 23:
				enterOuterAlt(_localctx, 23);
				{
				setState(625);
				property_rgb();
				}
				break;
			case 24:
				enterOuterAlt(_localctx, 24);
				{
				setState(626);
				property_rgba();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_boolContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_boolContext val_bool() {
			return getRuleContext(Val_boolContext.class,0);
		}
		public Property_boolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_bool; }
	}

	public final Property_boolContext property_bool() throws RecognitionException {
		Property_boolContext _localctx = new Property_boolContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_property_bool);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(629);
			property_name();
			setState(630);
			match(T__17);
			setState(631);
			display_name();
			setState(632);
			match(T__18);
			setState(633);
			match(T__58);
			setState(634);
			match(T__19);
			setState(635);
			match(T__15);
			setState(636);
			val_bool();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_intContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_intContext val_int() {
			return getRuleContext(Val_intContext.class,0);
		}
		public Property_intContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_int; }
	}

	public final Property_intContext property_int() throws RecognitionException {
		Property_intContext _localctx = new Property_intContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_property_int);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(638);
			property_name();
			setState(639);
			match(T__17);
			setState(640);
			display_name();
			setState(641);
			match(T__18);
			setState(642);
			match(T__52);
			setState(643);
			match(T__19);
			setState(644);
			match(T__15);
			setState(645);
			val_int();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_uintContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_uintContext val_uint() {
			return getRuleContext(Val_uintContext.class,0);
		}
		public Property_uintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_uint; }
	}

	public final Property_uintContext property_uint() throws RecognitionException {
		Property_uintContext _localctx = new Property_uintContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_property_uint);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(647);
			property_name();
			setState(648);
			match(T__17);
			setState(649);
			display_name();
			setState(650);
			match(T__18);
			setState(651);
			match(T__59);
			setState(652);
			match(T__19);
			setState(653);
			match(T__15);
			setState(654);
			val_uint();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_floatContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_floatContext val_float() {
			return getRuleContext(Val_floatContext.class,0);
		}
		public Property_floatContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_float; }
	}

	public final Property_floatContext property_float() throws RecognitionException {
		Property_floatContext _localctx = new Property_floatContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_property_float);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(656);
			property_name();
			setState(657);
			match(T__17);
			setState(658);
			display_name();
			setState(659);
			match(T__18);
			setState(660);
			match(T__28);
			setState(661);
			match(T__19);
			setState(662);
			match(T__15);
			setState(663);
			val_float();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_doubleContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_doubleContext val_double() {
			return getRuleContext(Val_doubleContext.class,0);
		}
		public Property_doubleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_double; }
	}

	public final Property_doubleContext property_double() throws RecognitionException {
		Property_doubleContext _localctx = new Property_doubleContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_property_double);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(665);
			property_name();
			setState(666);
			match(T__17);
			setState(667);
			display_name();
			setState(668);
			match(T__18);
			setState(669);
			match(T__60);
			setState(670);
			match(T__19);
			setState(671);
			match(T__15);
			setState(672);
			val_double();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_bool2Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_bool2Context val_bool2() {
			return getRuleContext(Val_bool2Context.class,0);
		}
		public Property_bool2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_bool2; }
	}

	public final Property_bool2Context property_bool2() throws RecognitionException {
		Property_bool2Context _localctx = new Property_bool2Context(_ctx, getState());
		enterRule(_localctx, 96, RULE_property_bool2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(674);
			property_name();
			setState(675);
			match(T__17);
			setState(676);
			display_name();
			setState(677);
			match(T__18);
			setState(678);
			match(T__61);
			setState(679);
			match(T__19);
			setState(680);
			match(T__15);
			setState(681);
			val_bool2();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_bool3Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_bool3Context val_bool3() {
			return getRuleContext(Val_bool3Context.class,0);
		}
		public Property_bool3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_bool3; }
	}

	public final Property_bool3Context property_bool3() throws RecognitionException {
		Property_bool3Context _localctx = new Property_bool3Context(_ctx, getState());
		enterRule(_localctx, 98, RULE_property_bool3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(683);
			property_name();
			setState(684);
			match(T__17);
			setState(685);
			display_name();
			setState(686);
			match(T__18);
			setState(687);
			match(T__62);
			setState(688);
			match(T__19);
			setState(689);
			match(T__15);
			setState(690);
			val_bool3();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_bool4Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_bool4Context val_bool4() {
			return getRuleContext(Val_bool4Context.class,0);
		}
		public Property_bool4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_bool4; }
	}

	public final Property_bool4Context property_bool4() throws RecognitionException {
		Property_bool4Context _localctx = new Property_bool4Context(_ctx, getState());
		enterRule(_localctx, 100, RULE_property_bool4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(692);
			property_name();
			setState(693);
			match(T__17);
			setState(694);
			display_name();
			setState(695);
			match(T__18);
			setState(696);
			match(T__63);
			setState(697);
			match(T__19);
			setState(698);
			match(T__15);
			setState(699);
			val_bool4();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_int2Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_int2Context val_int2() {
			return getRuleContext(Val_int2Context.class,0);
		}
		public Property_int2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_int2; }
	}

	public final Property_int2Context property_int2() throws RecognitionException {
		Property_int2Context _localctx = new Property_int2Context(_ctx, getState());
		enterRule(_localctx, 102, RULE_property_int2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(701);
			property_name();
			setState(702);
			match(T__17);
			setState(703);
			display_name();
			setState(704);
			match(T__18);
			setState(705);
			match(T__64);
			setState(706);
			match(T__19);
			setState(707);
			match(T__15);
			setState(708);
			val_int2();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_int3Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_int3Context val_int3() {
			return getRuleContext(Val_int3Context.class,0);
		}
		public Property_int3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_int3; }
	}

	public final Property_int3Context property_int3() throws RecognitionException {
		Property_int3Context _localctx = new Property_int3Context(_ctx, getState());
		enterRule(_localctx, 104, RULE_property_int3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(710);
			property_name();
			setState(711);
			match(T__17);
			setState(712);
			display_name();
			setState(713);
			match(T__18);
			setState(714);
			match(T__65);
			setState(715);
			match(T__19);
			setState(716);
			match(T__15);
			setState(717);
			val_int3();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_int4Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_int4Context val_int4() {
			return getRuleContext(Val_int4Context.class,0);
		}
		public Property_int4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_int4; }
	}

	public final Property_int4Context property_int4() throws RecognitionException {
		Property_int4Context _localctx = new Property_int4Context(_ctx, getState());
		enterRule(_localctx, 106, RULE_property_int4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(719);
			property_name();
			setState(720);
			match(T__17);
			setState(721);
			display_name();
			setState(722);
			match(T__18);
			setState(723);
			match(T__66);
			setState(724);
			match(T__19);
			setState(725);
			match(T__15);
			setState(726);
			val_int4();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_uint2Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_uint2Context val_uint2() {
			return getRuleContext(Val_uint2Context.class,0);
		}
		public Property_uint2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_uint2; }
	}

	public final Property_uint2Context property_uint2() throws RecognitionException {
		Property_uint2Context _localctx = new Property_uint2Context(_ctx, getState());
		enterRule(_localctx, 108, RULE_property_uint2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(728);
			property_name();
			setState(729);
			match(T__17);
			setState(730);
			display_name();
			setState(731);
			match(T__18);
			setState(732);
			match(T__67);
			setState(733);
			match(T__19);
			setState(734);
			match(T__15);
			setState(735);
			val_uint2();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_uint3Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_uint3Context val_uint3() {
			return getRuleContext(Val_uint3Context.class,0);
		}
		public Property_uint3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_uint3; }
	}

	public final Property_uint3Context property_uint3() throws RecognitionException {
		Property_uint3Context _localctx = new Property_uint3Context(_ctx, getState());
		enterRule(_localctx, 110, RULE_property_uint3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(737);
			property_name();
			setState(738);
			match(T__17);
			setState(739);
			display_name();
			setState(740);
			match(T__18);
			setState(741);
			match(T__68);
			setState(742);
			match(T__19);
			setState(743);
			match(T__15);
			setState(744);
			val_uint3();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_uint4Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_uint4Context val_uint4() {
			return getRuleContext(Val_uint4Context.class,0);
		}
		public Property_uint4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_uint4; }
	}

	public final Property_uint4Context property_uint4() throws RecognitionException {
		Property_uint4Context _localctx = new Property_uint4Context(_ctx, getState());
		enterRule(_localctx, 112, RULE_property_uint4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(746);
			property_name();
			setState(747);
			match(T__17);
			setState(748);
			display_name();
			setState(749);
			match(T__18);
			setState(750);
			match(T__69);
			setState(751);
			match(T__19);
			setState(752);
			match(T__15);
			setState(753);
			val_uint4();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_float2Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_float2Context val_float2() {
			return getRuleContext(Val_float2Context.class,0);
		}
		public Property_float2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_float2; }
	}

	public final Property_float2Context property_float2() throws RecognitionException {
		Property_float2Context _localctx = new Property_float2Context(_ctx, getState());
		enterRule(_localctx, 114, RULE_property_float2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(755);
			property_name();
			setState(756);
			match(T__17);
			setState(757);
			display_name();
			setState(758);
			match(T__18);
			setState(759);
			match(T__29);
			setState(760);
			match(T__19);
			setState(761);
			match(T__15);
			setState(762);
			val_float2();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_float3Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_float3Context val_float3() {
			return getRuleContext(Val_float3Context.class,0);
		}
		public Property_float3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_float3; }
	}

	public final Property_float3Context property_float3() throws RecognitionException {
		Property_float3Context _localctx = new Property_float3Context(_ctx, getState());
		enterRule(_localctx, 116, RULE_property_float3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(764);
			property_name();
			setState(765);
			match(T__17);
			setState(766);
			display_name();
			setState(767);
			match(T__18);
			setState(768);
			match(T__30);
			setState(769);
			match(T__19);
			setState(770);
			match(T__15);
			setState(771);
			val_float3();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_float4Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_float4Context val_float4() {
			return getRuleContext(Val_float4Context.class,0);
		}
		public Property_float4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_float4; }
	}

	public final Property_float4Context property_float4() throws RecognitionException {
		Property_float4Context _localctx = new Property_float4Context(_ctx, getState());
		enterRule(_localctx, 118, RULE_property_float4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(773);
			property_name();
			setState(774);
			match(T__17);
			setState(775);
			display_name();
			setState(776);
			match(T__18);
			setState(777);
			match(T__31);
			setState(778);
			match(T__19);
			setState(779);
			match(T__15);
			setState(780);
			val_float4();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_double2Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_double2Context val_double2() {
			return getRuleContext(Val_double2Context.class,0);
		}
		public Property_double2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_double2; }
	}

	public final Property_double2Context property_double2() throws RecognitionException {
		Property_double2Context _localctx = new Property_double2Context(_ctx, getState());
		enterRule(_localctx, 120, RULE_property_double2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(782);
			property_name();
			setState(783);
			match(T__17);
			setState(784);
			display_name();
			setState(785);
			match(T__18);
			setState(786);
			match(T__70);
			setState(787);
			match(T__19);
			setState(788);
			match(T__15);
			setState(789);
			val_double2();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_double3Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_double3Context val_double3() {
			return getRuleContext(Val_double3Context.class,0);
		}
		public Property_double3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_double3; }
	}

	public final Property_double3Context property_double3() throws RecognitionException {
		Property_double3Context _localctx = new Property_double3Context(_ctx, getState());
		enterRule(_localctx, 122, RULE_property_double3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(791);
			property_name();
			setState(792);
			match(T__17);
			setState(793);
			display_name();
			setState(794);
			match(T__18);
			setState(795);
			match(T__71);
			setState(796);
			match(T__19);
			setState(797);
			match(T__15);
			setState(798);
			val_double3();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_double4Context extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_double4Context val_double4() {
			return getRuleContext(Val_double4Context.class,0);
		}
		public Property_double4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_double4; }
	}

	public final Property_double4Context property_double4() throws RecognitionException {
		Property_double4Context _localctx = new Property_double4Context(_ctx, getState());
		enterRule(_localctx, 124, RULE_property_double4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(800);
			property_name();
			setState(801);
			match(T__17);
			setState(802);
			display_name();
			setState(803);
			match(T__18);
			setState(804);
			match(T__72);
			setState(805);
			match(T__19);
			setState(806);
			match(T__15);
			setState(807);
			val_double4();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_2DContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_tex2dContext val_tex2d() {
			return getRuleContext(Val_tex2dContext.class,0);
		}
		public Property_2DContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_2D; }
	}

	public final Property_2DContext property_2D() throws RecognitionException {
		Property_2DContext _localctx = new Property_2DContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_property_2D);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(809);
			property_name();
			setState(810);
			match(T__17);
			setState(811);
			display_name();
			setState(812);
			match(T__18);
			setState(813);
			match(T__48);
			setState(814);
			match(T__19);
			setState(815);
			match(T__15);
			setState(816);
			val_tex2d();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_cubeContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_texcubeContext val_texcube() {
			return getRuleContext(Val_texcubeContext.class,0);
		}
		public Property_cubeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_cube; }
	}

	public final Property_cubeContext property_cube() throws RecognitionException {
		Property_cubeContext _localctx = new Property_cubeContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_property_cube);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(818);
			property_name();
			setState(819);
			match(T__17);
			setState(820);
			display_name();
			setState(821);
			match(T__18);
			setState(822);
			match(T__73);
			setState(823);
			match(T__19);
			setState(824);
			match(T__15);
			setState(825);
			val_texcube();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_rgbContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_float3Context val_float3() {
			return getRuleContext(Val_float3Context.class,0);
		}
		public Property_rgbContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_rgb; }
	}

	public final Property_rgbContext property_rgb() throws RecognitionException {
		Property_rgbContext _localctx = new Property_rgbContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_property_rgb);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(827);
			property_name();
			setState(828);
			match(T__17);
			setState(829);
			display_name();
			setState(830);
			match(T__18);
			setState(831);
			match(T__74);
			setState(832);
			match(T__19);
			setState(833);
			match(T__15);
			setState(834);
			val_float3();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_rgbaContext extends ParserRuleContext {
		public Property_nameContext property_name() {
			return getRuleContext(Property_nameContext.class,0);
		}
		public Display_nameContext display_name() {
			return getRuleContext(Display_nameContext.class,0);
		}
		public Val_float4Context val_float4() {
			return getRuleContext(Val_float4Context.class,0);
		}
		public Property_rgbaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_rgba; }
	}

	public final Property_rgbaContext property_rgba() throws RecognitionException {
		Property_rgbaContext _localctx = new Property_rgbaContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_property_rgba);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(836);
			property_name();
			setState(837);
			match(T__17);
			setState(838);
			display_name();
			setState(839);
			match(T__18);
			setState(840);
			match(T__75);
			setState(841);
			match(T__19);
			setState(842);
			match(T__15);
			setState(843);
			val_float4();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_boolContext extends ParserRuleContext {
		public TerminalNode BooleanLiteral() { return getToken(ushaderParser.BooleanLiteral, 0); }
		public Val_boolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_bool; }
	}

	public final Val_boolContext val_bool() throws RecognitionException {
		Val_boolContext _localctx = new Val_boolContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_val_bool);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(845);
			match(BooleanLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_intContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public TerminalNode Sign() { return getToken(ushaderParser.Sign, 0); }
		public Val_intContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_int; }
	}

	public final Val_intContext val_int() throws RecognitionException {
		Val_intContext _localctx = new Val_intContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_val_int);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(848);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Sign) {
				{
				setState(847);
				match(Sign);
				}
			}

			setState(850);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_uintContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Val_uintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_uint; }
	}

	public final Val_uintContext val_uint() throws RecognitionException {
		Val_uintContext _localctx = new Val_uintContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_val_uint);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(852);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_floatContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public TerminalNode FloatingLiteral() { return getToken(ushaderParser.FloatingLiteral, 0); }
		public Val_floatContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_float; }
	}

	public final Val_floatContext val_float() throws RecognitionException {
		Val_floatContext _localctx = new Val_floatContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_val_float);
		int _la;
		try {
			setState(862);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(855);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__39) {
					{
					setState(854);
					match(T__39);
					}
				}

				setState(857);
				match(IntegerLiteral);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(859);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__39) {
					{
					setState(858);
					match(T__39);
					}
				}

				setState(861);
				match(FloatingLiteral);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_doubleContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public TerminalNode Sign() { return getToken(ushaderParser.Sign, 0); }
		public TerminalNode FloatingLiteral() { return getToken(ushaderParser.FloatingLiteral, 0); }
		public Val_doubleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_double; }
	}

	public final Val_doubleContext val_double() throws RecognitionException {
		Val_doubleContext _localctx = new Val_doubleContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_val_double);
		int _la;
		try {
			setState(872);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(865);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Sign) {
					{
					setState(864);
					match(Sign);
					}
				}

				setState(867);
				match(IntegerLiteral);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(869);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Sign) {
					{
					setState(868);
					match(Sign);
					}
				}

				setState(871);
				match(FloatingLiteral);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_bool2Context extends ParserRuleContext {
		public List<Val_boolContext> val_bool() {
			return getRuleContexts(Val_boolContext.class);
		}
		public Val_boolContext val_bool(int i) {
			return getRuleContext(Val_boolContext.class,i);
		}
		public Val_bool2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_bool2; }
	}

	public final Val_bool2Context val_bool2() throws RecognitionException {
		Val_bool2Context _localctx = new Val_bool2Context(_ctx, getState());
		enterRule(_localctx, 144, RULE_val_bool2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(874);
			match(T__17);
			setState(875);
			val_bool();
			setState(876);
			match(T__18);
			setState(877);
			val_bool();
			setState(878);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_bool3Context extends ParserRuleContext {
		public List<Val_boolContext> val_bool() {
			return getRuleContexts(Val_boolContext.class);
		}
		public Val_boolContext val_bool(int i) {
			return getRuleContext(Val_boolContext.class,i);
		}
		public Val_bool3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_bool3; }
	}

	public final Val_bool3Context val_bool3() throws RecognitionException {
		Val_bool3Context _localctx = new Val_bool3Context(_ctx, getState());
		enterRule(_localctx, 146, RULE_val_bool3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(880);
			match(T__17);
			setState(881);
			val_bool();
			setState(882);
			match(T__18);
			setState(883);
			val_bool();
			setState(884);
			match(T__18);
			setState(885);
			val_bool();
			setState(886);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_bool4Context extends ParserRuleContext {
		public List<Val_boolContext> val_bool() {
			return getRuleContexts(Val_boolContext.class);
		}
		public Val_boolContext val_bool(int i) {
			return getRuleContext(Val_boolContext.class,i);
		}
		public Val_bool4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_bool4; }
	}

	public final Val_bool4Context val_bool4() throws RecognitionException {
		Val_bool4Context _localctx = new Val_bool4Context(_ctx, getState());
		enterRule(_localctx, 148, RULE_val_bool4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(888);
			match(T__17);
			setState(889);
			val_bool();
			setState(890);
			match(T__18);
			setState(891);
			val_bool();
			setState(892);
			match(T__18);
			setState(893);
			val_bool();
			setState(894);
			match(T__18);
			setState(895);
			val_bool();
			setState(896);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_int2Context extends ParserRuleContext {
		public List<Val_intContext> val_int() {
			return getRuleContexts(Val_intContext.class);
		}
		public Val_intContext val_int(int i) {
			return getRuleContext(Val_intContext.class,i);
		}
		public Val_int2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_int2; }
	}

	public final Val_int2Context val_int2() throws RecognitionException {
		Val_int2Context _localctx = new Val_int2Context(_ctx, getState());
		enterRule(_localctx, 150, RULE_val_int2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(898);
			match(T__17);
			setState(899);
			val_int();
			setState(900);
			match(T__18);
			setState(901);
			val_int();
			setState(902);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_int3Context extends ParserRuleContext {
		public List<Val_intContext> val_int() {
			return getRuleContexts(Val_intContext.class);
		}
		public Val_intContext val_int(int i) {
			return getRuleContext(Val_intContext.class,i);
		}
		public Val_int3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_int3; }
	}

	public final Val_int3Context val_int3() throws RecognitionException {
		Val_int3Context _localctx = new Val_int3Context(_ctx, getState());
		enterRule(_localctx, 152, RULE_val_int3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(904);
			match(T__17);
			setState(905);
			val_int();
			setState(906);
			match(T__18);
			setState(907);
			val_int();
			setState(908);
			match(T__18);
			setState(909);
			val_int();
			setState(910);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_int4Context extends ParserRuleContext {
		public List<Val_intContext> val_int() {
			return getRuleContexts(Val_intContext.class);
		}
		public Val_intContext val_int(int i) {
			return getRuleContext(Val_intContext.class,i);
		}
		public Val_int4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_int4; }
	}

	public final Val_int4Context val_int4() throws RecognitionException {
		Val_int4Context _localctx = new Val_int4Context(_ctx, getState());
		enterRule(_localctx, 154, RULE_val_int4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(912);
			match(T__17);
			setState(913);
			val_int();
			setState(914);
			match(T__18);
			setState(915);
			val_int();
			setState(916);
			match(T__18);
			setState(917);
			val_int();
			setState(918);
			match(T__18);
			setState(919);
			val_int();
			setState(920);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_uint2Context extends ParserRuleContext {
		public List<Val_uintContext> val_uint() {
			return getRuleContexts(Val_uintContext.class);
		}
		public Val_uintContext val_uint(int i) {
			return getRuleContext(Val_uintContext.class,i);
		}
		public Val_uint2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_uint2; }
	}

	public final Val_uint2Context val_uint2() throws RecognitionException {
		Val_uint2Context _localctx = new Val_uint2Context(_ctx, getState());
		enterRule(_localctx, 156, RULE_val_uint2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(922);
			match(T__17);
			setState(923);
			val_uint();
			setState(924);
			match(T__18);
			setState(925);
			val_uint();
			setState(926);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_uint3Context extends ParserRuleContext {
		public List<Val_uintContext> val_uint() {
			return getRuleContexts(Val_uintContext.class);
		}
		public Val_uintContext val_uint(int i) {
			return getRuleContext(Val_uintContext.class,i);
		}
		public Val_uint3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_uint3; }
	}

	public final Val_uint3Context val_uint3() throws RecognitionException {
		Val_uint3Context _localctx = new Val_uint3Context(_ctx, getState());
		enterRule(_localctx, 158, RULE_val_uint3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(928);
			match(T__17);
			setState(929);
			val_uint();
			setState(930);
			match(T__18);
			setState(931);
			val_uint();
			setState(932);
			match(T__18);
			setState(933);
			val_uint();
			setState(934);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_uint4Context extends ParserRuleContext {
		public List<Val_uintContext> val_uint() {
			return getRuleContexts(Val_uintContext.class);
		}
		public Val_uintContext val_uint(int i) {
			return getRuleContext(Val_uintContext.class,i);
		}
		public Val_uint4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_uint4; }
	}

	public final Val_uint4Context val_uint4() throws RecognitionException {
		Val_uint4Context _localctx = new Val_uint4Context(_ctx, getState());
		enterRule(_localctx, 160, RULE_val_uint4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(936);
			match(T__17);
			setState(937);
			val_uint();
			setState(938);
			match(T__18);
			setState(939);
			val_uint();
			setState(940);
			match(T__18);
			setState(941);
			val_uint();
			setState(942);
			match(T__18);
			setState(943);
			val_uint();
			setState(944);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_float2Context extends ParserRuleContext {
		public List<Val_floatContext> val_float() {
			return getRuleContexts(Val_floatContext.class);
		}
		public Val_floatContext val_float(int i) {
			return getRuleContext(Val_floatContext.class,i);
		}
		public Val_float2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_float2; }
	}

	public final Val_float2Context val_float2() throws RecognitionException {
		Val_float2Context _localctx = new Val_float2Context(_ctx, getState());
		enterRule(_localctx, 162, RULE_val_float2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(946);
			match(T__17);
			setState(947);
			val_float();
			setState(948);
			match(T__18);
			setState(949);
			val_float();
			setState(950);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_float3Context extends ParserRuleContext {
		public List<Val_floatContext> val_float() {
			return getRuleContexts(Val_floatContext.class);
		}
		public Val_floatContext val_float(int i) {
			return getRuleContext(Val_floatContext.class,i);
		}
		public Val_float3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_float3; }
	}

	public final Val_float3Context val_float3() throws RecognitionException {
		Val_float3Context _localctx = new Val_float3Context(_ctx, getState());
		enterRule(_localctx, 164, RULE_val_float3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(952);
			match(T__17);
			setState(953);
			val_float();
			setState(954);
			match(T__18);
			setState(955);
			val_float();
			setState(956);
			match(T__18);
			setState(957);
			val_float();
			setState(958);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_float4Context extends ParserRuleContext {
		public List<Val_floatContext> val_float() {
			return getRuleContexts(Val_floatContext.class);
		}
		public Val_floatContext val_float(int i) {
			return getRuleContext(Val_floatContext.class,i);
		}
		public Val_float4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_float4; }
	}

	public final Val_float4Context val_float4() throws RecognitionException {
		Val_float4Context _localctx = new Val_float4Context(_ctx, getState());
		enterRule(_localctx, 166, RULE_val_float4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(960);
			match(T__17);
			setState(961);
			val_float();
			setState(962);
			match(T__18);
			setState(963);
			val_float();
			setState(964);
			match(T__18);
			setState(965);
			val_float();
			setState(966);
			match(T__18);
			setState(967);
			val_float();
			setState(968);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_double2Context extends ParserRuleContext {
		public List<Val_doubleContext> val_double() {
			return getRuleContexts(Val_doubleContext.class);
		}
		public Val_doubleContext val_double(int i) {
			return getRuleContext(Val_doubleContext.class,i);
		}
		public Val_double2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_double2; }
	}

	public final Val_double2Context val_double2() throws RecognitionException {
		Val_double2Context _localctx = new Val_double2Context(_ctx, getState());
		enterRule(_localctx, 168, RULE_val_double2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(970);
			match(T__17);
			setState(971);
			val_double();
			setState(972);
			match(T__18);
			setState(973);
			val_double();
			setState(974);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_double3Context extends ParserRuleContext {
		public List<Val_doubleContext> val_double() {
			return getRuleContexts(Val_doubleContext.class);
		}
		public Val_doubleContext val_double(int i) {
			return getRuleContext(Val_doubleContext.class,i);
		}
		public Val_double3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_double3; }
	}

	public final Val_double3Context val_double3() throws RecognitionException {
		Val_double3Context _localctx = new Val_double3Context(_ctx, getState());
		enterRule(_localctx, 170, RULE_val_double3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(976);
			match(T__17);
			setState(977);
			val_double();
			setState(978);
			match(T__18);
			setState(979);
			val_double();
			setState(980);
			match(T__18);
			setState(981);
			val_double();
			setState(982);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_double4Context extends ParserRuleContext {
		public List<Val_doubleContext> val_double() {
			return getRuleContexts(Val_doubleContext.class);
		}
		public Val_doubleContext val_double(int i) {
			return getRuleContext(Val_doubleContext.class,i);
		}
		public Val_double4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_double4; }
	}

	public final Val_double4Context val_double4() throws RecognitionException {
		Val_double4Context _localctx = new Val_double4Context(_ctx, getState());
		enterRule(_localctx, 172, RULE_val_double4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(984);
			match(T__17);
			setState(985);
			val_double();
			setState(986);
			match(T__18);
			setState(987);
			val_double();
			setState(988);
			match(T__18);
			setState(989);
			val_double();
			setState(990);
			match(T__18);
			setState(991);
			val_double();
			setState(992);
			match(T__19);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_tex2dContext extends ParserRuleContext {
		public Default_texture_2dContext default_texture_2d() {
			return getRuleContext(Default_texture_2dContext.class,0);
		}
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Val_tex2dContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_tex2d; }
	}

	public final Val_tex2dContext val_tex2d() throws RecognitionException {
		Val_tex2dContext _localctx = new Val_tex2dContext(_ctx, getState());
		enterRule(_localctx, 174, RULE_val_tex2d);
		try {
			setState(996);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__76:
			case T__77:
			case T__78:
				enterOuterAlt(_localctx, 1);
				{
				setState(994);
				default_texture_2d();
				}
				break;
			case StringLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(995);
				match(StringLiteral);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Default_texture_2dContext extends ParserRuleContext {
		public Default_texture_2dContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_default_texture_2d; }
	}

	public final Default_texture_2dContext default_texture_2d() throws RecognitionException {
		Default_texture_2dContext _localctx = new Default_texture_2dContext(_ctx, getState());
		enterRule(_localctx, 176, RULE_default_texture_2d);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(998);
			_la = _input.LA(1);
			if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (T__76 - 77)) | (1L << (T__77 - 77)) | (1L << (T__78 - 77)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_texcubeContext extends ParserRuleContext {
		public Default_texture_cubeContext default_texture_cube() {
			return getRuleContext(Default_texture_cubeContext.class,0);
		}
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Val_texcubeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_texcube; }
	}

	public final Val_texcubeContext val_texcube() throws RecognitionException {
		Val_texcubeContext _localctx = new Val_texcubeContext(_ctx, getState());
		enterRule(_localctx, 178, RULE_val_texcube);
		try {
			setState(1002);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__76:
			case T__77:
				enterOuterAlt(_localctx, 1);
				{
				setState(1000);
				default_texture_cube();
				}
				break;
			case StringLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(1001);
				match(StringLiteral);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Default_texture_cubeContext extends ParserRuleContext {
		public Default_texture_cubeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_default_texture_cube; }
	}

	public final Default_texture_cubeContext default_texture_cube() throws RecognitionException {
		Default_texture_cubeContext _localctx = new Default_texture_cubeContext(_ctx, getState());
		enterRule(_localctx, 180, RULE_default_texture_cube);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1004);
			_la = _input.LA(1);
			if ( !(_la==T__76 || _la==T__77) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Property_nameContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public Property_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property_name; }
	}

	public final Property_nameContext property_name() throws RecognitionException {
		Property_nameContext _localctx = new Property_nameContext(_ctx, getState());
		enterRule(_localctx, 182, RULE_property_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1006);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Display_nameContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(ushaderParser.StringLiteral, 0); }
		public Display_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_display_name; }
	}

	public final Display_nameContext display_name() throws RecognitionException {
		Display_nameContext _localctx = new Display_nameContext(_ctx, getState());
		enterRule(_localctx, 184, RULE_display_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1008);
			match(StringLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Root_signatureContext extends ParserRuleContext {
		public List<Root_parameterContext> root_parameter() {
			return getRuleContexts(Root_parameterContext.class);
		}
		public Root_parameterContext root_parameter(int i) {
			return getRuleContext(Root_parameterContext.class,i);
		}
		public Root_signatureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_root_signature; }
	}

	public final Root_signatureContext root_signature() throws RecognitionException {
		Root_signatureContext _localctx = new Root_signatureContext(_ctx, getState());
		enterRule(_localctx, 186, RULE_root_signature);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1010);
			match(T__79);
			setState(1011);
			match(T__1);
			setState(1013); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(1012);
				root_parameter();
				}
				}
				setState(1015); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==RootDescriptorType );
			setState(1017);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Root_parameterContext extends ParserRuleContext {
		public TerminalNode RootDescriptorType() { return getToken(ushaderParser.RootDescriptorType, 0); }
		public Register_indexContext register_index() {
			return getRuleContext(Register_indexContext.class,0);
		}
		public Register_numContext register_num() {
			return getRuleContext(Register_numContext.class,0);
		}
		public Root_parameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_root_parameter; }
	}

	public final Root_parameterContext root_parameter() throws RecognitionException {
		Root_parameterContext _localctx = new Root_parameterContext(_ctx, getState());
		enterRule(_localctx, 188, RULE_root_parameter);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1019);
			match(RootDescriptorType);
			setState(1024);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__45) {
				{
				setState(1020);
				match(T__45);
				setState(1021);
				register_num();
				setState(1022);
				match(T__46);
				}
			}

			setState(1026);
			match(T__15);
			setState(1027);
			register_index();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Register_indexContext extends ParserRuleContext {
		public Shader_registerContext shader_register() {
			return getRuleContext(Shader_registerContext.class,0);
		}
		public Register_spaceContext register_space() {
			return getRuleContext(Register_spaceContext.class,0);
		}
		public Register_indexContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_register_index; }
	}

	public final Register_indexContext register_index() throws RecognitionException {
		Register_indexContext _localctx = new Register_indexContext(_ctx, getState());
		enterRule(_localctx, 190, RULE_register_index);
		try {
			setState(1036);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IntegerLiteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(1029);
				shader_register();
				}
				break;
			case T__17:
				enterOuterAlt(_localctx, 2);
				{
				setState(1030);
				match(T__17);
				setState(1031);
				shader_register();
				setState(1032);
				match(T__18);
				setState(1033);
				register_space();
				setState(1034);
				match(T__19);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Shader_registerContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Shader_registerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shader_register; }
	}

	public final Shader_registerContext shader_register() throws RecognitionException {
		Shader_registerContext _localctx = new Shader_registerContext(_ctx, getState());
		enterRule(_localctx, 192, RULE_shader_register);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1038);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Register_spaceContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Register_spaceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_register_space; }
	}

	public final Register_spaceContext register_space() throws RecognitionException {
		Register_spaceContext _localctx = new Register_spaceContext(_ctx, getState());
		enterRule(_localctx, 194, RULE_register_space);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1040);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Register_numContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Register_numContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_register_num; }
	}

	public final Register_numContext register_num() throws RecognitionException {
		Register_numContext _localctx = new Register_numContext(_ctx, getState());
		enterRule(_localctx, 196, RULE_register_num);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1042);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VsContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public VsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vs; }
	}

	public final VsContext vs() throws RecognitionException {
		VsContext _localctx = new VsContext(_ctx, getState());
		enterRule(_localctx, 198, RULE_vs);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1044);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PsContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(ushaderParser.ID, 0); }
		public PsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ps; }
	}

	public final PsContext ps() throws RecognitionException {
		PsContext _localctx = new PsContext(_ctx, getState());
		enterRule(_localctx, 200, RULE_ps);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1046);
			match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Pass_statementContext extends ParserRuleContext {
		public Render_state_setupContext render_state_setup() {
			return getRuleContext(Render_state_setupContext.class,0);
		}
		public TagsContext tags() {
			return getRuleContext(TagsContext.class,0);
		}
		public QueueContext queue() {
			return getRuleContext(QueueContext.class,0);
		}
		public Pass_statementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pass_statement; }
	}

	public final Pass_statementContext pass_statement() throws RecognitionException {
		Pass_statementContext _localctx = new Pass_statementContext(_ctx, getState());
		enterRule(_localctx, 202, RULE_pass_statement);
		try {
			setState(1051);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__7:
			case T__80:
			case T__81:
			case T__82:
			case T__83:
			case T__88:
			case T__89:
			case T__90:
				enterOuterAlt(_localctx, 1);
				{
				setState(1048);
				render_state_setup();
				}
				break;
			case T__5:
				enterOuterAlt(_localctx, 2);
				{
				setState(1049);
				tags();
				}
				break;
			case T__105:
				enterOuterAlt(_localctx, 3);
				{
				setState(1050);
				queue();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Render_state_setupContext extends ParserRuleContext {
		public FillContext fill() {
			return getRuleContext(FillContext.class,0);
		}
		public CullContext cull() {
			return getRuleContext(CullContext.class,0);
		}
		public ZtestContext ztest() {
			return getRuleContext(ZtestContext.class,0);
		}
		public Zwrite_offContext zwrite_off() {
			return getRuleContext(Zwrite_offContext.class,0);
		}
		public BlendContext blend() {
			return getRuleContext(BlendContext.class,0);
		}
		public Blend_opContext blend_op() {
			return getRuleContext(Blend_opContext.class,0);
		}
		public Color_maskContext color_mask() {
			return getRuleContext(Color_maskContext.class,0);
		}
		public StencilContext stencil() {
			return getRuleContext(StencilContext.class,0);
		}
		public Render_state_setupContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_render_state_setup; }
	}

	public final Render_state_setupContext render_state_setup() throws RecognitionException {
		Render_state_setupContext _localctx = new Render_state_setupContext(_ctx, getState());
		enterRule(_localctx, 204, RULE_render_state_setup);
		try {
			setState(1061);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__80:
				enterOuterAlt(_localctx, 1);
				{
				setState(1053);
				fill();
				}
				break;
			case T__81:
				enterOuterAlt(_localctx, 2);
				{
				setState(1054);
				cull();
				}
				break;
			case T__82:
				enterOuterAlt(_localctx, 3);
				{
				setState(1055);
				ztest();
				}
				break;
			case T__83:
				enterOuterAlt(_localctx, 4);
				{
				setState(1056);
				zwrite_off();
				}
				break;
			case T__7:
				enterOuterAlt(_localctx, 5);
				{
				setState(1057);
				blend();
				}
				break;
			case T__88:
				enterOuterAlt(_localctx, 6);
				{
				setState(1058);
				blend_op();
				}
				break;
			case T__89:
				enterOuterAlt(_localctx, 7);
				{
				setState(1059);
				color_mask();
				}
				break;
			case T__90:
				enterOuterAlt(_localctx, 8);
				{
				setState(1060);
				stencil();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FillContext extends ParserRuleContext {
		public TerminalNode FillMode() { return getToken(ushaderParser.FillMode, 0); }
		public FillContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fill; }
	}

	public final FillContext fill() throws RecognitionException {
		FillContext _localctx = new FillContext(_ctx, getState());
		enterRule(_localctx, 206, RULE_fill);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1063);
			match(T__80);
			setState(1064);
			match(FillMode);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CullContext extends ParserRuleContext {
		public TerminalNode CullMode() { return getToken(ushaderParser.CullMode, 0); }
		public CullContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cull; }
	}

	public final CullContext cull() throws RecognitionException {
		CullContext _localctx = new CullContext(_ctx, getState());
		enterRule(_localctx, 208, RULE_cull);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1066);
			match(T__81);
			setState(1067);
			match(CullMode);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ZtestContext extends ParserRuleContext {
		public TerminalNode Comparator() { return getToken(ushaderParser.Comparator, 0); }
		public ZtestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ztest; }
	}

	public final ZtestContext ztest() throws RecognitionException {
		ZtestContext _localctx = new ZtestContext(_ctx, getState());
		enterRule(_localctx, 210, RULE_ztest);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1069);
			match(T__82);
			setState(1070);
			match(Comparator);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Zwrite_offContext extends ParserRuleContext {
		public Zwrite_offContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_zwrite_off; }
	}

	public final Zwrite_offContext zwrite_off() throws RecognitionException {
		Zwrite_offContext _localctx = new Zwrite_offContext(_ctx, getState());
		enterRule(_localctx, 212, RULE_zwrite_off);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1072);
			match(T__83);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlendContext extends ParserRuleContext {
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public Blend_exprContext blend_expr() {
			return getRuleContext(Blend_exprContext.class,0);
		}
		public BlendContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend; }
	}

	public final BlendContext blend() throws RecognitionException {
		BlendContext _localctx = new BlendContext(_ctx, getState());
		enterRule(_localctx, 214, RULE_blend);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1074);
			match(T__7);
			setState(1079);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__45) {
				{
				setState(1075);
				match(T__45);
				setState(1076);
				index();
				setState(1077);
				match(T__46);
				}
			}

			setState(1082);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__17) {
				{
				setState(1081);
				blend_expr();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_exprContext extends ParserRuleContext {
		public Blend_src_factor_colorContext blend_src_factor_color() {
			return getRuleContext(Blend_src_factor_colorContext.class,0);
		}
		public Blend_dst_factor_colorContext blend_dst_factor_color() {
			return getRuleContext(Blend_dst_factor_colorContext.class,0);
		}
		public Blend_src_factor_alphaContext blend_src_factor_alpha() {
			return getRuleContext(Blend_src_factor_alphaContext.class,0);
		}
		public Blend_dst_factor_alphaContext blend_dst_factor_alpha() {
			return getRuleContext(Blend_dst_factor_alphaContext.class,0);
		}
		public Blend_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_expr; }
	}

	public final Blend_exprContext blend_expr() throws RecognitionException {
		Blend_exprContext _localctx = new Blend_exprContext(_ctx, getState());
		enterRule(_localctx, 216, RULE_blend_expr);
		try {
			setState(1100);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1084);
				match(T__17);
				setState(1085);
				blend_src_factor_color();
				setState(1086);
				match(T__18);
				setState(1087);
				blend_dst_factor_color();
				setState(1088);
				match(T__19);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1090);
				match(T__17);
				setState(1091);
				blend_src_factor_color();
				setState(1092);
				match(T__18);
				setState(1093);
				blend_dst_factor_color();
				setState(1094);
				match(T__18);
				setState(1095);
				blend_src_factor_alpha();
				setState(1096);
				match(T__18);
				setState(1097);
				blend_dst_factor_alpha();
				setState(1098);
				match(T__19);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IndexContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public IndexContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_index; }
	}

	public final IndexContext index() throws RecognitionException {
		IndexContext _localctx = new IndexContext(_ctx, getState());
		enterRule(_localctx, 218, RULE_index);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1102);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_src_factor_colorContext extends ParserRuleContext {
		public Blend_factorContext blend_factor() {
			return getRuleContext(Blend_factorContext.class,0);
		}
		public Blend_src_factor_colorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_src_factor_color; }
	}

	public final Blend_src_factor_colorContext blend_src_factor_color() throws RecognitionException {
		Blend_src_factor_colorContext _localctx = new Blend_src_factor_colorContext(_ctx, getState());
		enterRule(_localctx, 220, RULE_blend_src_factor_color);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1104);
			blend_factor();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_dst_factor_colorContext extends ParserRuleContext {
		public Blend_factorContext blend_factor() {
			return getRuleContext(Blend_factorContext.class,0);
		}
		public Blend_dst_factor_colorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_dst_factor_color; }
	}

	public final Blend_dst_factor_colorContext blend_dst_factor_color() throws RecognitionException {
		Blend_dst_factor_colorContext _localctx = new Blend_dst_factor_colorContext(_ctx, getState());
		enterRule(_localctx, 222, RULE_blend_dst_factor_color);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1106);
			blend_factor();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_src_factor_alphaContext extends ParserRuleContext {
		public TerminalNode BlendFactorAlpha() { return getToken(ushaderParser.BlendFactorAlpha, 0); }
		public Blend_src_factor_alphaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_src_factor_alpha; }
	}

	public final Blend_src_factor_alphaContext blend_src_factor_alpha() throws RecognitionException {
		Blend_src_factor_alphaContext _localctx = new Blend_src_factor_alphaContext(_ctx, getState());
		enterRule(_localctx, 224, RULE_blend_src_factor_alpha);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1108);
			match(BlendFactorAlpha);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_dst_factor_alphaContext extends ParserRuleContext {
		public TerminalNode BlendFactorAlpha() { return getToken(ushaderParser.BlendFactorAlpha, 0); }
		public Blend_dst_factor_alphaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_dst_factor_alpha; }
	}

	public final Blend_dst_factor_alphaContext blend_dst_factor_alpha() throws RecognitionException {
		Blend_dst_factor_alphaContext _localctx = new Blend_dst_factor_alphaContext(_ctx, getState());
		enterRule(_localctx, 226, RULE_blend_dst_factor_alpha);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1110);
			match(BlendFactorAlpha);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_factorContext extends ParserRuleContext {
		public TerminalNode BlendFactorAlpha() { return getToken(ushaderParser.BlendFactorAlpha, 0); }
		public Blend_factorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_factor; }
	}

	public final Blend_factorContext blend_factor() throws RecognitionException {
		Blend_factorContext _localctx = new Blend_factorContext(_ctx, getState());
		enterRule(_localctx, 228, RULE_blend_factor);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1112);
			_la = _input.LA(1);
			if ( !(((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (T__84 - 85)) | (1L << (T__85 - 85)) | (1L << (T__86 - 85)) | (1L << (T__87 - 85)) | (1L << (BlendFactorAlpha - 85)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_opContext extends ParserRuleContext {
		public Blend_op_colorContext blend_op_color() {
			return getRuleContext(Blend_op_colorContext.class,0);
		}
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public Blend_op_alphaContext blend_op_alpha() {
			return getRuleContext(Blend_op_alphaContext.class,0);
		}
		public Blend_opContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_op; }
	}

	public final Blend_opContext blend_op() throws RecognitionException {
		Blend_opContext _localctx = new Blend_opContext(_ctx, getState());
		enterRule(_localctx, 230, RULE_blend_op);
		int _la;
		try {
			setState(1135);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1114);
				match(T__88);
				setState(1119);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__45) {
					{
					setState(1115);
					match(T__45);
					setState(1116);
					index();
					setState(1117);
					match(T__46);
					}
				}

				setState(1121);
				blend_op_color();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1122);
				match(T__88);
				setState(1127);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__45) {
					{
					setState(1123);
					match(T__45);
					setState(1124);
					index();
					setState(1125);
					match(T__46);
					}
				}

				setState(1129);
				match(T__17);
				setState(1130);
				blend_op_color();
				setState(1131);
				match(T__18);
				setState(1132);
				blend_op_alpha();
				setState(1133);
				match(T__19);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_op_colorContext extends ParserRuleContext {
		public TerminalNode BlendOpEnum() { return getToken(ushaderParser.BlendOpEnum, 0); }
		public Blend_op_colorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_op_color; }
	}

	public final Blend_op_colorContext blend_op_color() throws RecognitionException {
		Blend_op_colorContext _localctx = new Blend_op_colorContext(_ctx, getState());
		enterRule(_localctx, 232, RULE_blend_op_color);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1137);
			match(BlendOpEnum);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Blend_op_alphaContext extends ParserRuleContext {
		public TerminalNode BlendOpEnum() { return getToken(ushaderParser.BlendOpEnum, 0); }
		public Blend_op_alphaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blend_op_alpha; }
	}

	public final Blend_op_alphaContext blend_op_alpha() throws RecognitionException {
		Blend_op_alphaContext _localctx = new Blend_op_alphaContext(_ctx, getState());
		enterRule(_localctx, 234, RULE_blend_op_alpha);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1139);
			match(BlendOpEnum);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Color_maskContext extends ParserRuleContext {
		public Color_mask_valueContext color_mask_value() {
			return getRuleContext(Color_mask_valueContext.class,0);
		}
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public Color_maskContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_color_mask; }
	}

	public final Color_maskContext color_mask() throws RecognitionException {
		Color_maskContext _localctx = new Color_maskContext(_ctx, getState());
		enterRule(_localctx, 236, RULE_color_mask);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1141);
			match(T__89);
			setState(1146);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==T__45) {
				{
				setState(1142);
				match(T__45);
				setState(1143);
				index();
				setState(1144);
				match(T__46);
				}
			}

			setState(1148);
			color_mask_value();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Color_mask_valueContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public TerminalNode ColorMask_RGBA() { return getToken(ushaderParser.ColorMask_RGBA, 0); }
		public Color_mask_valueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_color_mask_value; }
	}

	public final Color_mask_valueContext color_mask_value() throws RecognitionException {
		Color_mask_valueContext _localctx = new Color_mask_valueContext(_ctx, getState());
		enterRule(_localctx, 238, RULE_color_mask_value);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1150);
			_la = _input.LA(1);
			if ( !(_la==ColorMask_RGBA || _la==IntegerLiteral) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StencilContext extends ParserRuleContext {
		public List<Stencil_state_setupContext> stencil_state_setup() {
			return getRuleContexts(Stencil_state_setupContext.class);
		}
		public Stencil_state_setupContext stencil_state_setup(int i) {
			return getRuleContext(Stencil_state_setupContext.class,i);
		}
		public StencilContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil; }
	}

	public final StencilContext stencil() throws RecognitionException {
		StencilContext _localctx = new StencilContext(_ctx, getState());
		enterRule(_localctx, 240, RULE_stencil);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1152);
			match(T__90);
			setState(1153);
			match(T__1);
			setState(1155); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(1154);
				stencil_state_setup();
				}
				}
				setState(1157); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==T__10 || ((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (T__91 - 92)) | (1L << (T__92 - 92)) | (1L << (T__93 - 92)) | (1L << (T__94 - 92)) | (1L << (T__95 - 92)) | (1L << (T__96 - 92)))) != 0) );
			setState(1159);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_state_setupContext extends ParserRuleContext {
		public Stencil_refContext stencil_ref() {
			return getRuleContext(Stencil_refContext.class,0);
		}
		public Stencil_mask_readContext stencil_mask_read() {
			return getRuleContext(Stencil_mask_readContext.class,0);
		}
		public Stencil_mask_writeContext stencil_mask_write() {
			return getRuleContext(Stencil_mask_writeContext.class,0);
		}
		public Stencil_compareContext stencil_compare() {
			return getRuleContext(Stencil_compareContext.class,0);
		}
		public Stencil_passContext stencil_pass() {
			return getRuleContext(Stencil_passContext.class,0);
		}
		public Stencil_failContext stencil_fail() {
			return getRuleContext(Stencil_failContext.class,0);
		}
		public Stencil_zfailContext stencil_zfail() {
			return getRuleContext(Stencil_zfailContext.class,0);
		}
		public Stencil_state_setupContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_state_setup; }
	}

	public final Stencil_state_setupContext stencil_state_setup() throws RecognitionException {
		Stencil_state_setupContext _localctx = new Stencil_state_setupContext(_ctx, getState());
		enterRule(_localctx, 242, RULE_stencil_state_setup);
		try {
			setState(1168);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__91:
				enterOuterAlt(_localctx, 1);
				{
				setState(1161);
				stencil_ref();
				}
				break;
			case T__92:
				enterOuterAlt(_localctx, 2);
				{
				setState(1162);
				stencil_mask_read();
				}
				break;
			case T__93:
				enterOuterAlt(_localctx, 3);
				{
				setState(1163);
				stencil_mask_write();
				}
				break;
			case T__94:
				enterOuterAlt(_localctx, 4);
				{
				setState(1164);
				stencil_compare();
				}
				break;
			case T__10:
				enterOuterAlt(_localctx, 5);
				{
				setState(1165);
				stencil_pass();
				}
				break;
			case T__95:
				enterOuterAlt(_localctx, 6);
				{
				setState(1166);
				stencil_fail();
				}
				break;
			case T__96:
				enterOuterAlt(_localctx, 7);
				{
				setState(1167);
				stencil_zfail();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_refContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Stencil_refContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_ref; }
	}

	public final Stencil_refContext stencil_ref() throws RecognitionException {
		Stencil_refContext _localctx = new Stencil_refContext(_ctx, getState());
		enterRule(_localctx, 244, RULE_stencil_ref);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1170);
			match(T__91);
			setState(1171);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_mask_readContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Stencil_mask_readContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_mask_read; }
	}

	public final Stencil_mask_readContext stencil_mask_read() throws RecognitionException {
		Stencil_mask_readContext _localctx = new Stencil_mask_readContext(_ctx, getState());
		enterRule(_localctx, 246, RULE_stencil_mask_read);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1173);
			match(T__92);
			setState(1174);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_mask_writeContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public Stencil_mask_writeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_mask_write; }
	}

	public final Stencil_mask_writeContext stencil_mask_write() throws RecognitionException {
		Stencil_mask_writeContext _localctx = new Stencil_mask_writeContext(_ctx, getState());
		enterRule(_localctx, 248, RULE_stencil_mask_write);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1176);
			match(T__93);
			setState(1177);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_compareContext extends ParserRuleContext {
		public TerminalNode Comparator() { return getToken(ushaderParser.Comparator, 0); }
		public Stencil_compareContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_compare; }
	}

	public final Stencil_compareContext stencil_compare() throws RecognitionException {
		Stencil_compareContext _localctx = new Stencil_compareContext(_ctx, getState());
		enterRule(_localctx, 250, RULE_stencil_compare);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1179);
			match(T__94);
			setState(1180);
			match(Comparator);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_passContext extends ParserRuleContext {
		public Stencil_opContext stencil_op() {
			return getRuleContext(Stencil_opContext.class,0);
		}
		public Stencil_passContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_pass; }
	}

	public final Stencil_passContext stencil_pass() throws RecognitionException {
		Stencil_passContext _localctx = new Stencil_passContext(_ctx, getState());
		enterRule(_localctx, 252, RULE_stencil_pass);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1182);
			match(T__10);
			setState(1183);
			stencil_op();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_failContext extends ParserRuleContext {
		public Stencil_opContext stencil_op() {
			return getRuleContext(Stencil_opContext.class,0);
		}
		public Stencil_failContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_fail; }
	}

	public final Stencil_failContext stencil_fail() throws RecognitionException {
		Stencil_failContext _localctx = new Stencil_failContext(_ctx, getState());
		enterRule(_localctx, 254, RULE_stencil_fail);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1185);
			match(T__95);
			setState(1186);
			stencil_op();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_zfailContext extends ParserRuleContext {
		public Stencil_opContext stencil_op() {
			return getRuleContext(Stencil_opContext.class,0);
		}
		public Stencil_zfailContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_zfail; }
	}

	public final Stencil_zfailContext stencil_zfail() throws RecognitionException {
		Stencil_zfailContext _localctx = new Stencil_zfailContext(_ctx, getState());
		enterRule(_localctx, 256, RULE_stencil_zfail);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1188);
			match(T__96);
			setState(1189);
			stencil_op();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Stencil_opContext extends ParserRuleContext {
		public Stencil_opContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stencil_op; }
	}

	public final Stencil_opContext stencil_op() throws RecognitionException {
		Stencil_opContext _localctx = new Stencil_opContext(_ctx, getState());
		enterRule(_localctx, 258, RULE_stencil_op);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1191);
			_la = _input.LA(1);
			if ( !(((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & ((1L << (T__97 - 98)) | (1L << (T__98 - 98)) | (1L << (T__99 - 98)) | (1L << (T__100 - 98)) | (1L << (T__101 - 98)) | (1L << (T__102 - 98)) | (1L << (T__103 - 98)) | (1L << (T__104 - 98)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QueueContext extends ParserRuleContext {
		public Val_queueContext val_queue() {
			return getRuleContext(Val_queueContext.class,0);
		}
		public QueueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_queue; }
	}

	public final QueueContext queue() throws RecognitionException {
		QueueContext _localctx = new QueueContext(_ctx, getState());
		enterRule(_localctx, 260, RULE_queue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1193);
			match(T__105);
			setState(1194);
			val_queue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Val_queueContext extends ParserRuleContext {
		public Queue_keyContext queue_key() {
			return getRuleContext(Queue_keyContext.class,0);
		}
		public TerminalNode IntegerLiteral() { return getToken(ushaderParser.IntegerLiteral, 0); }
		public TerminalNode Sign() { return getToken(ushaderParser.Sign, 0); }
		public Val_queueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_val_queue; }
	}

	public final Val_queueContext val_queue() throws RecognitionException {
		Val_queueContext _localctx = new Val_queueContext(_ctx, getState());
		enterRule(_localctx, 262, RULE_val_queue);
		try {
			setState(1202);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1196);
				queue_key();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1197);
				match(IntegerLiteral);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1198);
				queue_key();
				setState(1199);
				match(Sign);
				setState(1200);
				match(IntegerLiteral);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Queue_keyContext extends ParserRuleContext {
		public Queue_keyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_queue_key; }
	}

	public final Queue_keyContext queue_key() throws RecognitionException {
		Queue_keyContext _localctx = new Queue_keyContext(_ctx, getState());
		enterRule(_localctx, 264, RULE_queue_key);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1204);
			_la = _input.LA(1);
			if ( !(((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (T__106 - 107)) | (1L << (T__107 - 107)) | (1L << (T__108 - 107)) | (1L << (T__109 - 107)) | (1L << (T__110 - 107)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 30:
			return cg_expr_member_sempred((Cg_expr_memberContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean cg_expr_member_sempred(Cg_expr_memberContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 1);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0088\u04b9\4\2\t"+
		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
		"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
		"\t\u0085\4\u0086\t\u0086\3\2\3\2\3\2\3\2\7\2\u0111\n\2\f\2\16\2\u0114"+
		"\13\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\5\3\u011d\n\3\3\4\3\4\3\4\7\4\u0122"+
		"\n\4\f\4\16\4\u0125\13\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\5\5\u012e\n\5\3\6"+
		"\3\6\3\6\3\6\3\6\7\6\u0135\n\6\f\6\16\6\u0138\13\6\3\6\3\6\3\7\3\7\3\7"+
		"\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n\3\n\7\n\u0149\n\n\f\n\16\n\u014c"+
		"\13\n\3\n\7\n\u014f\n\n\f\n\16\n\u0152\13\n\3\n\3\n\3\13\3\13\3\13\3\13"+
		"\3\13\7\13\u015b\n\13\f\13\16\13\u015e\13\13\3\13\3\13\3\f\3\f\3\f\3\f"+
		"\7\f\u0166\n\f\f\f\16\f\u0169\13\f\3\f\3\f\5\f\u016d\n\f\3\r\3\r\3\r\3"+
		"\r\3\r\3\r\3\r\5\r\u0176\n\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3"+
		"\17\3\17\3\17\7\17\u0183\n\17\f\17\16\17\u0186\13\17\5\17\u0188\n\17\3"+
		"\17\3\17\3\17\5\17\u018d\n\17\3\17\3\17\7\17\u0191\n\17\f\17\16\17\u0194"+
		"\13\17\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u019c\n\20\3\21\3\21\3\22\3"+
		"\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u01a8\n\22\3\23\3\23\7\23\u01ac"+
		"\n\23\f\23\16\23\u01af\13\23\3\23\3\23\3\24\3\24\3\24\3\24\3\25\3\25\3"+
		"\25\3\26\3\26\5\26\u01bc\n\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27"+
		"\3\30\3\30\5\30\u01c8\n\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31"+
		"\3\31\3\32\3\32\3\32\5\32\u01d7\n\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33"+
		"\3\33\3\33\5\33\u01e2\n\33\3\34\3\34\3\34\3\34\3\34\7\34\u01e9\n\34\f"+
		"\34\16\34\u01ec\13\34\5\34\u01ee\n\34\3\34\3\34\3\35\3\35\3\35\3\35\3"+
		"\36\3\36\3\36\3\36\5\36\u01fa\n\36\3\37\3\37\3\37\3\37\3\37\7\37\u0201"+
		"\n\37\f\37\16\37\u0204\13\37\3\37\3\37\3 \3 \3 \3 \3 \3 \7 \u020e\n \f"+
		" \16 \u0211\13 \3!\3!\3!\3\"\3\"\3\"\3\"\3#\3#\5#\u021c\n#\3#\3#\3#\3"+
		"$\3$\3$\3$\3%\3%\3%\3&\3&\3&\6&\u022b\n&\r&\16&\u022c\3&\3&\3\'\7\'\u0232"+
		"\n\'\f\'\16\'\u0235\13\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u023f\n\'"+
		"\3(\3(\3(\3(\3(\3(\3(\3)\3)\5)\u024a\n)\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+"+
		"\3+\3+\3+\3+\3+\3+\5+\u025c\n+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,"+
		"\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\5,\u0276\n,\3-\3-\3-\3-\3-\3-\3-\3-"+
		"\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3/\3\60\3\60\3"+
		"\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3"+
		"\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3"+
		"\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3"+
		"\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3"+
		"\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3"+
		"8\38\38\38\38\38\38\38\38\39\39\39\39\39\39\39\39\39\3:\3:\3:\3:\3:\3"+
		":\3:\3:\3:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3<\3<\3<\3<\3=\3"+
		"=\3=\3=\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3"+
		"?\3?\3?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3"+
		"B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3"+
		"D\3D\3E\3E\3F\5F\u0353\nF\3F\3F\3G\3G\3H\5H\u035a\nH\3H\3H\5H\u035e\n"+
		"H\3H\5H\u0361\nH\3I\5I\u0364\nI\3I\3I\5I\u0368\nI\3I\5I\u036b\nI\3J\3"+
		"J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3L\3L\3L\3"+
		"M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3"+
		"O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3R\3"+
		"R\3R\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3"+
		"U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3X\3X\3X\3X\3X\3X\3"+
		"X\3X\3X\3X\3Y\3Y\5Y\u03e7\nY\3Z\3Z\3[\3[\5[\u03ed\n[\3\\\3\\\3]\3]\3^"+
		"\3^\3_\3_\3_\6_\u03f8\n_\r_\16_\u03f9\3_\3_\3`\3`\3`\3`\3`\5`\u0403\n"+
		"`\3`\3`\3`\3a\3a\3a\3a\3a\3a\3a\5a\u040f\na\3b\3b\3c\3c\3d\3d\3e\3e\3"+
		"f\3f\3g\3g\3g\5g\u041e\ng\3h\3h\3h\3h\3h\3h\3h\3h\5h\u0428\nh\3i\3i\3"+
		"i\3j\3j\3j\3k\3k\3k\3l\3l\3m\3m\3m\3m\3m\5m\u043a\nm\3m\5m\u043d\nm\3"+
		"n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\5n\u044f\nn\3o\3o\3p\3"+
		"p\3q\3q\3r\3r\3s\3s\3t\3t\3u\3u\3u\3u\3u\5u\u0462\nu\3u\3u\3u\3u\3u\3"+
		"u\5u\u046a\nu\3u\3u\3u\3u\3u\3u\5u\u0472\nu\3v\3v\3w\3w\3x\3x\3x\3x\3"+
		"x\5x\u047d\nx\3x\3x\3y\3y\3z\3z\3z\6z\u0486\nz\rz\16z\u0487\3z\3z\3{\3"+
		"{\3{\3{\3{\3{\3{\5{\u0493\n{\3|\3|\3|\3}\3}\3}\3~\3~\3~\3\177\3\177\3"+
		"\177\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082\3"+
		"\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085"+
		"\3\u0085\3\u0085\3\u0085\5\u0085\u04b5\n\u0085\3\u0086\3\u0086\3\u0086"+
		"\2\3>\u0087\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66"+
		"8:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a"+
		"\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2"+
		"\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba"+
		"\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2"+
		"\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea"+
		"\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102"+
		"\u0104\u0106\u0108\u010a\2\r\4\2\27#\u0083\u0083\3\2%(\3\2*+\3\2,.\3\2"+
		";<\3\2OQ\3\2OP\4\2WZrr\3\2z{\3\2dk\3\2mq\2\u04b0\2\u010c\3\2\2\2\4\u011c"+
		"\3\2\2\2\6\u011e\3\2\2\2\b\u012d\3\2\2\2\n\u012f\3\2\2\2\f\u013b\3\2\2"+
		"\2\16\u013f\3\2\2\2\20\u0142\3\2\2\2\22\u0145\3\2\2\2\24\u0155\3\2\2\2"+
		"\26\u0161\3\2\2\2\30\u0175\3\2\2\2\32\u0177\3\2\2\2\34\u017c\3\2\2\2\36"+
		"\u0197\3\2\2\2 \u019d\3\2\2\2\"\u01a7\3\2\2\2$\u01a9\3\2\2\2&\u01b2\3"+
		"\2\2\2(\u01b6\3\2\2\2*\u01bb\3\2\2\2,\u01c0\3\2\2\2.\u01c7\3\2\2\2\60"+
		"\u01ce\3\2\2\2\62\u01d6\3\2\2\2\64\u01e1\3\2\2\2\66\u01e3\3\2\2\28\u01f1"+
		"\3\2\2\2:\u01f9\3\2\2\2<\u01fb\3\2\2\2>\u0207\3\2\2\2@\u0212\3\2\2\2B"+
		"\u0215\3\2\2\2D\u021b\3\2\2\2F\u0220\3\2\2\2H\u0224\3\2\2\2J\u0227\3\2"+
		"\2\2L\u0233\3\2\2\2N\u0240\3\2\2\2P\u0249\3\2\2\2R\u024b\3\2\2\2T\u025b"+
		"\3\2\2\2V\u0275\3\2\2\2X\u0277\3\2\2\2Z\u0280\3\2\2\2\\\u0289\3\2\2\2"+
		"^\u0292\3\2\2\2`\u029b\3\2\2\2b\u02a4\3\2\2\2d\u02ad\3\2\2\2f\u02b6\3"+
		"\2\2\2h\u02bf\3\2\2\2j\u02c8\3\2\2\2l\u02d1\3\2\2\2n\u02da\3\2\2\2p\u02e3"+
		"\3\2\2\2r\u02ec\3\2\2\2t\u02f5\3\2\2\2v\u02fe\3\2\2\2x\u0307\3\2\2\2z"+
		"\u0310\3\2\2\2|\u0319\3\2\2\2~\u0322\3\2\2\2\u0080\u032b\3\2\2\2\u0082"+
		"\u0334\3\2\2\2\u0084\u033d\3\2\2\2\u0086\u0346\3\2\2\2\u0088\u034f\3\2"+
		"\2\2\u008a\u0352\3\2\2\2\u008c\u0356\3\2\2\2\u008e\u0360\3\2\2\2\u0090"+
		"\u036a\3\2\2\2\u0092\u036c\3\2\2\2\u0094\u0372\3\2\2\2\u0096\u037a\3\2"+
		"\2\2\u0098\u0384\3\2\2\2\u009a\u038a\3\2\2\2\u009c\u0392\3\2\2\2\u009e"+
		"\u039c\3\2\2\2\u00a0\u03a2\3\2\2\2\u00a2\u03aa\3\2\2\2\u00a4\u03b4\3\2"+
		"\2\2\u00a6\u03ba\3\2\2\2\u00a8\u03c2\3\2\2\2\u00aa\u03cc\3\2\2\2\u00ac"+
		"\u03d2\3\2\2\2\u00ae\u03da\3\2\2\2\u00b0\u03e6\3\2\2\2\u00b2\u03e8\3\2"+
		"\2\2\u00b4\u03ec\3\2\2\2\u00b6\u03ee\3\2\2\2\u00b8\u03f0\3\2\2\2\u00ba"+
		"\u03f2\3\2\2\2\u00bc\u03f4\3\2\2\2\u00be\u03fd\3\2\2\2\u00c0\u040e\3\2"+
		"\2\2\u00c2\u0410\3\2\2\2\u00c4\u0412\3\2\2\2\u00c6\u0414\3\2\2\2\u00c8"+
		"\u0416\3\2\2\2\u00ca\u0418\3\2\2\2\u00cc\u041d\3\2\2\2\u00ce\u0427\3\2"+
		"\2\2\u00d0\u0429\3\2\2\2\u00d2\u042c\3\2\2\2\u00d4\u042f\3\2\2\2\u00d6"+
		"\u0432\3\2\2\2\u00d8\u0434\3\2\2\2\u00da\u044e\3\2\2\2\u00dc\u0450\3\2"+
		"\2\2\u00de\u0452\3\2\2\2\u00e0\u0454\3\2\2\2\u00e2\u0456\3\2\2\2\u00e4"+
		"\u0458\3\2\2\2\u00e6\u045a\3\2\2\2\u00e8\u0471\3\2\2\2\u00ea\u0473\3\2"+
		"\2\2\u00ec\u0475\3\2\2\2\u00ee\u0477\3\2\2\2\u00f0\u0480\3\2\2\2\u00f2"+
		"\u0482\3\2\2\2\u00f4\u0492\3\2\2\2\u00f6\u0494\3\2\2\2\u00f8\u0497\3\2"+
		"\2\2\u00fa\u049a\3\2\2\2\u00fc\u049d\3\2\2\2\u00fe\u04a0\3\2\2\2\u0100"+
		"\u04a3\3\2\2\2\u0102\u04a6\3\2\2\2\u0104\u04a9\3\2\2\2\u0106\u04ab\3\2"+
		"\2\2\u0108\u04b4\3\2\2\2\u010a\u04b6\3\2\2\2\u010c\u010d\7\3\2\2\u010d"+
		"\u010e\7t\2\2\u010e\u0112\7\4\2\2\u010f\u0111\5\4\3\2\u0110\u010f\3\2"+
		"\2\2\u0111\u0114\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0113\3\2\2\2\u0113"+
		"\u0115\3\2\2\2\u0114\u0112\3\2\2\2\u0115\u0116\7\5\2\2\u0116\u0117\7\2"+
		"\2\3\u0117\3\3\2\2\2\u0118\u011d\5J&\2\u0119\u011d\5\6\4\2\u011a\u011b"+
		"\7\6\2\2\u011b\u011d\7t\2\2\u011c\u0118\3\2\2\2\u011c\u0119\3\2\2\2\u011c"+
		"\u011a\3\2\2\2\u011d\5\3\2\2\2\u011e\u011f\7\7\2\2\u011f\u0123\7\4\2\2"+
		"\u0120\u0122\5\b\5\2\u0121\u0120\3\2\2\2\u0122\u0125\3\2\2\2\u0123\u0121"+
		"\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0126\3\2\2\2\u0125\u0123\3\2\2\2\u0126"+
		"\u0127\7\5\2\2\u0127\7\3\2\2\2\u0128\u012e\5\22\n\2\u0129\u012e\5\n\6"+
		"\2\u012a\u012e\5\f\7\2\u012b\u012e\5\16\b\2\u012c\u012e\5\20\t\2\u012d"+
		"\u0128\3\2\2\2\u012d\u0129\3\2\2\2\u012d\u012a\3\2\2\2\u012d\u012b\3\2"+
		"\2\2\u012d\u012c\3\2\2\2\u012e\t\3\2\2\2\u012f\u0130\7\b\2\2\u0130\u0136"+
		"\7\4\2\2\u0131\u0132\7t\2\2\u0132\u0133\7\t\2\2\u0133\u0135\7t\2\2\u0134"+
		"\u0131\3\2\2\2\u0135\u0138\3\2\2\2\u0136\u0134\3\2\2\2\u0136\u0137\3\2"+
		"\2\2\u0137\u0139\3\2\2\2\u0138\u0136\3\2\2\2\u0139\u013a\7\5\2\2\u013a"+
		"\13\3\2\2\2\u013b\u013c\7\n\2\2\u013c\u013d\5\u00e6t\2\u013d\u013e\5\u00e6"+
		"t\2\u013e\r\3\2\2\2\u013f\u0140\7\13\2\2\u0140\u0141\5\u008aF\2\u0141"+
		"\17\3\2\2\2\u0142\u0143\7\f\2\2\u0143\u0144\7t\2\2\u0144\21\3\2\2\2\u0145"+
		"\u0146\7\r\2\2\u0146\u014a\7\4\2\2\u0147\u0149\5\u00ccg\2\u0148\u0147"+
		"\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u014b\3\2\2\2\u014b"+
		"\u0150\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014f\5\24\13\2\u014e\u014d\3"+
		"\2\2\2\u014f\u0152\3\2\2\2\u0150\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151"+
		"\u0153\3\2\2\2\u0152\u0150\3\2\2\2\u0153\u0154\7\5\2\2\u0154\23\3\2\2"+
		"\2\u0155\u015c\7\16\2\2\u0156\u015b\7\u0088\2\2\u0157\u015b\5\34\17\2"+
		"\u0158\u015b\5\32\16\2\u0159\u015b\5\26\f\2\u015a\u0156\3\2\2\2\u015a"+
		"\u0157\3\2\2\2\u015a\u0158\3\2\2\2\u015a\u0159\3\2\2\2\u015b\u015e\3\2"+
		"\2\2\u015c\u015a\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015f\3\2\2\2\u015e"+
		"\u015c\3\2\2\2\u015f\u0160\7\17\2\2\u0160\25\3\2\2\2\u0161\u0162\7\20"+
		"\2\2\u0162\u0163\7\u0083\2\2\u0163\u0167\7\4\2\2\u0164\u0166\5\30\r\2"+
		"\u0165\u0164\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2\u0167\u0168"+
		"\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016c\7\5\2\2\u016b"+
		"\u016d\7\21\2\2\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\27\3\2\2"+
		"\2\u016e\u0176\7\u0088\2\2\u016f\u0170\5 \21\2\u0170\u0171\7\u0083\2\2"+
		"\u0171\u0172\7\22\2\2\u0172\u0173\7\u0083\2\2\u0173\u0174\7\21\2\2\u0174"+
		"\u0176\3\2\2\2\u0175\u016e\3\2\2\2\u0175\u016f\3\2\2\2\u0176\31\3\2\2"+
		"\2\u0177\u0178\7\23\2\2\u0178\u0179\5 \21\2\u0179\u017a\7\u0083\2\2\u017a"+
		"\u017b\7\21\2\2\u017b\33\3\2\2\2\u017c\u017d\5 \21\2\u017d\u017e\7\u0083"+
		"\2\2\u017e\u0187\7\24\2\2\u017f\u0184\5\36\20\2\u0180\u0181\7\25\2\2\u0181"+
		"\u0183\5\36\20\2\u0182\u0180\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3"+
		"\2\2\2\u0184\u0185\3\2\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2\2\2\u0187"+
		"\u017f\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018c\7\26"+
		"\2\2\u018a\u018b\7\22\2\2\u018b\u018d\7\u0083\2\2\u018c\u018a\3\2\2\2"+
		"\u018c\u018d\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u0192\7\4\2\2\u018f\u0191"+
		"\5\"\22\2\u0190\u018f\3\2\2\2\u0191\u0194\3\2\2\2\u0192\u0190\3\2\2\2"+
		"\u0192\u0193\3\2\2\2\u0193\u0195\3\2\2\2\u0194\u0192\3\2\2\2\u0195\u0196"+
		"\7\5\2\2\u0196\35\3\2\2\2\u0197\u0198\5 \21\2\u0198\u019b\7\u0083\2\2"+
		"\u0199\u019a\7\22\2\2\u019a\u019c\7\u0083\2\2\u019b\u0199\3\2\2\2\u019b"+
		"\u019c\3\2\2\2\u019c\37\3\2\2\2\u019d\u019e\t\2\2\2\u019e!\3\2\2\2\u019f"+
		"\u01a8\7\u0088\2\2\u01a0\u01a8\5$\23\2\u01a1\u01a8\5&\24\2\u01a2\u01a8"+
		"\5*\26\2\u01a3\u01a8\5,\27\2\u01a4\u01a8\5.\30\2\u01a5\u01a8\5(\25\2\u01a6"+
		"\u01a8\5\60\31\2\u01a7\u019f\3\2\2\2\u01a7\u01a0\3\2\2\2\u01a7\u01a1\3"+
		"\2\2\2\u01a7\u01a2\3\2\2\2\u01a7\u01a3\3\2\2\2\u01a7\u01a4\3\2\2\2\u01a7"+
		"\u01a5\3\2\2\2\u01a7\u01a6\3\2\2\2\u01a8#\3\2\2\2\u01a9\u01ad\7\4\2\2"+
		"\u01aa\u01ac\5\"\22\2\u01ab\u01aa\3\2\2\2\u01ac\u01af\3\2\2\2\u01ad\u01ab"+
		"\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\3\2\2\2\u01af\u01ad\3\2\2\2\u01b0"+
		"\u01b1\7\5\2\2\u01b1%\3\2\2\2\u01b2\u01b3\7$\2\2\u01b3\u01b4\5\62\32\2"+
		"\u01b4\u01b5\7\21\2\2\u01b5\'\3\2\2\2\u01b6\u01b7\5\66\34\2\u01b7\u01b8"+
		"\7\21\2\2\u01b8)\3\2\2\2\u01b9\u01bc\7\u0083\2\2\u01ba\u01bc\5 \21\2\u01bb"+
		"\u01b9\3\2\2\2\u01bb\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01be\7\u0083"+
		"\2\2\u01be\u01bf\7\21\2\2\u01bf+\3\2\2\2\u01c0\u01c1\5\62\32\2\u01c1\u01c2"+
		"\7\t\2\2\u01c2\u01c3\5\62\32\2\u01c3\u01c4\7\21\2\2\u01c4-\3\2\2\2\u01c5"+
		"\u01c8\7\u0083\2\2\u01c6\u01c8\5 \21\2\u01c7\u01c5\3\2\2\2\u01c7\u01c6"+
		"\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01ca\7\u0083\2\2\u01ca\u01cb\7\t\2"+
		"\2\u01cb\u01cc\5\62\32\2\u01cc\u01cd\7\21\2\2\u01cd/\3\2\2\2\u01ce\u01cf"+
		"\5\62\32\2\u01cf\u01d0\t\3\2\2\u01d0\u01d1\5\62\32\2\u01d1\u01d2\7\21"+
		"\2\2\u01d2\61\3\2\2\2\u01d3\u01d7\5D#\2\u01d4\u01d7\5F$\2\u01d5\u01d7"+
		"\5\64\33\2\u01d6\u01d3\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d6\u01d5\3\2\2\2"+
		"\u01d7\63\3\2\2\2\u01d8\u01e2\7\u0083\2\2\u01d9\u01e2\5@!\2\u01da\u01e2"+
		"\58\35\2\u01db\u01e2\5:\36\2\u01dc\u01e2\5<\37\2\u01dd\u01e2\5\66\34\2"+
		"\u01de\u01e2\5> \2\u01df\u01e2\5B\"\2\u01e0\u01e2\5H%\2\u01e1\u01d8\3"+
		"\2\2\2\u01e1\u01d9\3\2\2\2\u01e1\u01da\3\2\2\2\u01e1\u01db\3\2\2\2\u01e1"+
		"\u01dc\3\2\2\2\u01e1\u01dd\3\2\2\2\u01e1\u01de\3\2\2\2\u01e1\u01df\3\2"+
		"\2\2\u01e1\u01e0\3\2\2\2\u01e2\65\3\2\2\2\u01e3\u01e4\7\u0083\2\2\u01e4"+
		"\u01ed\7\24\2\2\u01e5\u01ea\5\62\32\2\u01e6\u01e7\7\25\2\2\u01e7\u01e9"+
		"\5\62\32\2\u01e8\u01e6\3\2\2\2\u01e9\u01ec\3\2\2\2\u01ea\u01e8\3\2\2\2"+
		"\u01ea\u01eb\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2\u01ed\u01e5"+
		"\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef\u01f0\7\26\2\2"+
		"\u01f0\67\3\2\2\2\u01f1\u01f2\7\24\2\2\u01f2\u01f3\5\62\32\2\u01f3\u01f4"+
		"\7\26\2\2\u01f49\3\2\2\2\u01f5\u01fa\5\u008eH\2\u01f6\u01fa\5\u00a4S\2"+
		"\u01f7\u01fa\5\u00a6T\2\u01f8\u01fa\5\u00a8U\2\u01f9\u01f5\3\2\2\2\u01f9"+
		"\u01f6\3\2\2\2\u01f9\u01f7\3\2\2\2\u01f9\u01f8\3\2\2\2\u01fa;\3\2\2\2"+
		"\u01fb\u01fc\5 \21\2\u01fc\u01fd\7\24\2\2\u01fd\u0202\5\62\32\2\u01fe"+
		"\u01ff\7\25\2\2\u01ff\u0201\5\62\32\2\u0200\u01fe\3\2\2\2\u0201\u0204"+
		"\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203\u0205\3\2\2\2\u0204"+
		"\u0202\3\2\2\2\u0205\u0206\7\26\2\2\u0206=\3\2\2\2\u0207\u0208\b \1\2"+
		"\u0208\u0209\7\u0083\2\2\u0209\u020f\3\2\2\2\u020a\u020b\f\3\2\2\u020b"+
		"\u020c\7)\2\2\u020c\u020e\7\u0083\2\2\u020d\u020a\3\2\2\2\u020e\u0211"+
		"\3\2\2\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2\2\2\u0210?\3\2\2\2\u0211"+
		"\u020f\3\2\2\2\u0212\u0213\7*\2\2\u0213\u0214\5\62\32\2\u0214A\3\2\2\2"+
		"\u0215\u0216\5\66\34\2\u0216\u0217\7)\2\2\u0217\u0218\7\u0083\2\2\u0218"+
		"C\3\2\2\2\u0219\u021c\5\64\33\2\u021a\u021c\5F$\2\u021b\u0219\3\2\2\2"+
		"\u021b\u021a\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u021e\t\4\2\2\u021e\u021f"+
		"\5\62\32\2\u021fE\3\2\2\2\u0220\u0221\5\64\33\2\u0221\u0222\t\5\2\2\u0222"+
		"\u0223\5\62\32\2\u0223G\3\2\2\2\u0224\u0225\5 \21\2\u0225\u0226\5:\36"+
		"\2\u0226I\3\2\2\2\u0227\u0228\7/\2\2\u0228\u022a\7\4\2\2\u0229\u022b\5"+
		"L\'\2\u022a\u0229\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022a\3\2\2\2\u022c"+
		"\u022d\3\2\2\2\u022d\u022e\3\2\2\2\u022e\u022f\7\5\2\2\u022fK\3\2\2\2"+
		"\u0230\u0232\5N(\2\u0231\u0230\3\2\2\2\u0232\u0235\3\2\2\2\u0233\u0231"+
		"\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0236\3\2\2\2\u0235\u0233\3\2\2\2\u0236"+
		"\u0237\7\u0083\2\2\u0237\u0238\7\24\2\2\u0238\u0239\7t\2\2\u0239\u023a"+
		"\7\25\2\2\u023a\u023b\5T+\2\u023b\u023e\7\26\2\2\u023c\u023d\7\t\2\2\u023d"+
		"\u023f\5P)\2\u023e\u023c\3\2\2\2\u023e\u023f\3\2\2\2\u023fM\3\2\2\2\u0240"+
		"\u0241\7\60\2\2\u0241\u0242\7\u0083\2\2\u0242\u0243\7\24\2\2\u0243\u0244"+
		"\7\u0083\2\2\u0244\u0245\7\26\2\2\u0245\u0246\7\61\2\2\u0246O\3\2\2\2"+
		"\u0247\u024a\5:\36\2\u0248\u024a\5R*\2\u0249\u0247\3\2\2\2\u0249\u0248"+
		"\3\2\2\2\u024aQ\3\2\2\2\u024b\u024c\7t\2\2\u024c\u024d\7\4\2\2\u024d\u024e"+
		"\7\5\2\2\u024eS\3\2\2\2\u024f\u025c\7\62\2\2\u0250\u025c\7\63\2\2\u0251"+
		"\u025c\7\64\2\2\u0252\u025c\7\65\2\2\u0253\u025c\7\66\2\2\u0254\u025c"+
		"\7\67\2\2\u0255\u025c\78\2\2\u0256\u025c\79\2\2\u0257\u025c\7:\2\2\u0258"+
		"\u025c\7\37\2\2\u0259\u025a\t\6\2\2\u025a\u025c\5\u00a4S\2\u025b\u024f"+
		"\3\2\2\2\u025b\u0250\3\2\2\2\u025b\u0251\3\2\2\2\u025b\u0252\3\2\2\2\u025b"+
		"\u0253\3\2\2\2\u025b\u0254\3\2\2\2\u025b\u0255\3\2\2\2\u025b\u0256\3\2"+
		"\2\2\u025b\u0257\3\2\2\2\u025b\u0258\3\2\2\2\u025b\u0259\3\2\2\2\u025c"+
		"U\3\2\2\2\u025d\u0276\5X-\2\u025e\u0276\5Z.\2\u025f\u0276\5\\/\2\u0260"+
		"\u0276\5^\60\2\u0261\u0276\5`\61\2\u0262\u0276\5b\62\2\u0263\u0276\5d"+
		"\63\2\u0264\u0276\5f\64\2\u0265\u0276\5h\65\2\u0266\u0276\5j\66\2\u0267"+
		"\u0276\5l\67\2\u0268\u0276\5n8\2\u0269\u0276\5p9\2\u026a\u0276\5r:\2\u026b"+
		"\u0276\5t;\2\u026c\u0276\5v<\2\u026d\u0276\5x=\2\u026e\u0276\5z>\2\u026f"+
		"\u0276\5|?\2\u0270\u0276\5~@\2\u0271\u0276\5\u0080A\2\u0272\u0276\5\u0082"+
		"B\2\u0273\u0276\5\u0084C\2\u0274\u0276\5\u0086D\2\u0275\u025d\3\2\2\2"+
		"\u0275\u025e\3\2\2\2\u0275\u025f\3\2\2\2\u0275\u0260\3\2\2\2\u0275\u0261"+
		"\3\2\2\2\u0275\u0262\3\2\2\2\u0275\u0263\3\2\2\2\u0275\u0264\3\2\2\2\u0275"+
		"\u0265\3\2\2\2\u0275\u0266\3\2\2\2\u0275\u0267\3\2\2\2\u0275\u0268\3\2"+
		"\2\2\u0275\u0269\3\2\2\2\u0275\u026a\3\2\2\2\u0275\u026b\3\2\2\2\u0275"+
		"\u026c\3\2\2\2\u0275\u026d\3\2\2\2\u0275\u026e\3\2\2\2\u0275\u026f\3\2"+
		"\2\2\u0275\u0270\3\2\2\2\u0275\u0271\3\2\2\2\u0275\u0272\3\2\2\2\u0275"+
		"\u0273\3\2\2\2\u0275\u0274\3\2\2\2\u0276W\3\2\2\2\u0277\u0278\5\u00b8"+
		"]\2\u0278\u0279\7\24\2\2\u0279\u027a\5\u00ba^\2\u027a\u027b\7\25\2\2\u027b"+
		"\u027c\7=\2\2\u027c\u027d\7\26\2\2\u027d\u027e\7\22\2\2\u027e\u027f\5"+
		"\u0088E\2\u027fY\3\2\2\2\u0280\u0281\5\u00b8]\2\u0281\u0282\7\24\2\2\u0282"+
		"\u0283\5\u00ba^\2\u0283\u0284\7\25\2\2\u0284\u0285\7\67\2\2\u0285\u0286"+
		"\7\26\2\2\u0286\u0287\7\22\2\2\u0287\u0288\5\u008aF\2\u0288[\3\2\2\2\u0289"+
		"\u028a\5\u00b8]\2\u028a\u028b\7\24\2\2\u028b\u028c\5\u00ba^\2\u028c\u028d"+
		"\7\25\2\2\u028d\u028e\7>\2\2\u028e\u028f\7\26\2\2\u028f\u0290\7\22\2\2"+
		"\u0290\u0291\5\u008cG\2\u0291]\3\2\2\2\u0292\u0293\5\u00b8]\2\u0293\u0294"+
		"\7\24\2\2\u0294\u0295\5\u00ba^\2\u0295\u0296\7\25\2\2\u0296\u0297\7\37"+
		"\2\2\u0297\u0298\7\26\2\2\u0298\u0299\7\22\2\2\u0299\u029a\5\u008eH\2"+
		"\u029a_\3\2\2\2\u029b\u029c\5\u00b8]\2\u029c\u029d\7\24\2\2\u029d\u029e"+
		"\5\u00ba^\2\u029e\u029f\7\25\2\2\u029f\u02a0\7?\2\2\u02a0\u02a1\7\26\2"+
		"\2\u02a1\u02a2\7\22\2\2\u02a2\u02a3\5\u0090I\2\u02a3a\3\2\2\2\u02a4\u02a5"+
		"\5\u00b8]\2\u02a5\u02a6\7\24\2\2\u02a6\u02a7\5\u00ba^\2\u02a7\u02a8\7"+
		"\25\2\2\u02a8\u02a9\7@\2\2\u02a9\u02aa\7\26\2\2\u02aa\u02ab\7\22\2\2\u02ab"+
		"\u02ac\5\u0092J\2\u02acc\3\2\2\2\u02ad\u02ae\5\u00b8]\2\u02ae\u02af\7"+
		"\24\2\2\u02af\u02b0\5\u00ba^\2\u02b0\u02b1\7\25\2\2\u02b1\u02b2\7A\2\2"+
		"\u02b2\u02b3\7\26\2\2\u02b3\u02b4\7\22\2\2\u02b4\u02b5\5\u0094K\2\u02b5"+
		"e\3\2\2\2\u02b6\u02b7\5\u00b8]\2\u02b7\u02b8\7\24\2\2\u02b8\u02b9\5\u00ba"+
		"^\2\u02b9\u02ba\7\25\2\2\u02ba\u02bb\7B\2\2\u02bb\u02bc\7\26\2\2\u02bc"+
		"\u02bd\7\22\2\2\u02bd\u02be\5\u0096L\2\u02beg\3\2\2\2\u02bf\u02c0\5\u00b8"+
		"]\2\u02c0\u02c1\7\24\2\2\u02c1\u02c2\5\u00ba^\2\u02c2\u02c3\7\25\2\2\u02c3"+
		"\u02c4\7C\2\2\u02c4\u02c5\7\26\2\2\u02c5\u02c6\7\22\2\2\u02c6\u02c7\5"+
		"\u0098M\2\u02c7i\3\2\2\2\u02c8\u02c9\5\u00b8]\2\u02c9\u02ca\7\24\2\2\u02ca"+
		"\u02cb\5\u00ba^\2\u02cb\u02cc\7\25\2\2\u02cc\u02cd\7D\2\2\u02cd\u02ce"+
		"\7\26\2\2\u02ce\u02cf\7\22\2\2\u02cf\u02d0\5\u009aN\2\u02d0k\3\2\2\2\u02d1"+
		"\u02d2\5\u00b8]\2\u02d2\u02d3\7\24\2\2\u02d3\u02d4\5\u00ba^\2\u02d4\u02d5"+
		"\7\25\2\2\u02d5\u02d6\7E\2\2\u02d6\u02d7\7\26\2\2\u02d7\u02d8\7\22\2\2"+
		"\u02d8\u02d9\5\u009cO\2\u02d9m\3\2\2\2\u02da\u02db\5\u00b8]\2\u02db\u02dc"+
		"\7\24\2\2\u02dc\u02dd\5\u00ba^\2\u02dd\u02de\7\25\2\2\u02de\u02df\7F\2"+
		"\2\u02df\u02e0\7\26\2\2\u02e0\u02e1\7\22\2\2\u02e1\u02e2\5\u009eP\2\u02e2"+
		"o\3\2\2\2\u02e3\u02e4\5\u00b8]\2\u02e4\u02e5\7\24\2\2\u02e5\u02e6\5\u00ba"+
		"^\2\u02e6\u02e7\7\25\2\2\u02e7\u02e8\7G\2\2\u02e8\u02e9\7\26\2\2\u02e9"+
		"\u02ea\7\22\2\2\u02ea\u02eb\5\u00a0Q\2\u02ebq\3\2\2\2\u02ec\u02ed\5\u00b8"+
		"]\2\u02ed\u02ee\7\24\2\2\u02ee\u02ef\5\u00ba^\2\u02ef\u02f0\7\25\2\2\u02f0"+
		"\u02f1\7H\2\2\u02f1\u02f2\7\26\2\2\u02f2\u02f3\7\22\2\2\u02f3\u02f4\5"+
		"\u00a2R\2\u02f4s\3\2\2\2\u02f5\u02f6\5\u00b8]\2\u02f6\u02f7\7\24\2\2\u02f7"+
		"\u02f8\5\u00ba^\2\u02f8\u02f9\7\25\2\2\u02f9\u02fa\7 \2\2\u02fa\u02fb"+
		"\7\26\2\2\u02fb\u02fc\7\22\2\2\u02fc\u02fd\5\u00a4S\2\u02fdu\3\2\2\2\u02fe"+
		"\u02ff\5\u00b8]\2\u02ff\u0300\7\24\2\2\u0300\u0301\5\u00ba^\2\u0301\u0302"+
		"\7\25\2\2\u0302\u0303\7!\2\2\u0303\u0304\7\26\2\2\u0304\u0305\7\22\2\2"+
		"\u0305\u0306\5\u00a6T\2\u0306w\3\2\2\2\u0307\u0308\5\u00b8]\2\u0308\u0309"+
		"\7\24\2\2\u0309\u030a\5\u00ba^\2\u030a\u030b\7\25\2\2\u030b\u030c\7\""+
		"\2\2\u030c\u030d\7\26\2\2\u030d\u030e\7\22\2\2\u030e\u030f\5\u00a8U\2"+
		"\u030fy\3\2\2\2\u0310\u0311\5\u00b8]\2\u0311\u0312\7\24\2\2\u0312\u0313"+
		"\5\u00ba^\2\u0313\u0314\7\25\2\2\u0314\u0315\7I\2\2\u0315\u0316\7\26\2"+
		"\2\u0316\u0317\7\22\2\2\u0317\u0318\5\u00aaV\2\u0318{\3\2\2\2\u0319\u031a"+
		"\5\u00b8]\2\u031a\u031b\7\24\2\2\u031b\u031c\5\u00ba^\2\u031c\u031d\7"+
		"\25\2\2\u031d\u031e\7J\2\2\u031e\u031f\7\26\2\2\u031f\u0320\7\22\2\2\u0320"+
		"\u0321\5\u00acW\2\u0321}\3\2\2\2\u0322\u0323\5\u00b8]\2\u0323\u0324\7"+
		"\24\2\2\u0324\u0325\5\u00ba^\2\u0325\u0326\7\25\2\2\u0326\u0327\7K\2\2"+
		"\u0327\u0328\7\26\2\2\u0328\u0329\7\22\2\2\u0329\u032a\5\u00aeX\2\u032a"+
		"\177\3\2\2\2\u032b\u032c\5\u00b8]\2\u032c\u032d\7\24\2\2\u032d\u032e\5"+
		"\u00ba^\2\u032e\u032f\7\25\2\2\u032f\u0330\7\63\2\2\u0330\u0331\7\26\2"+
		"\2\u0331\u0332\7\22\2\2\u0332\u0333\5\u00b0Y\2\u0333\u0081\3\2\2\2\u0334"+
		"\u0335\5\u00b8]\2\u0335\u0336\7\24\2\2\u0336\u0337\5\u00ba^\2\u0337\u0338"+
		"\7\25\2\2\u0338\u0339\7L\2\2\u0339\u033a\7\26\2\2\u033a\u033b\7\22\2\2"+
		"\u033b\u033c\5\u00b4[\2\u033c\u0083\3\2\2\2\u033d\u033e\5\u00b8]\2\u033e"+
		"\u033f\7\24\2\2\u033f\u0340\5\u00ba^\2\u0340\u0341\7\25\2\2\u0341\u0342"+
		"\7M\2\2\u0342\u0343\7\26\2\2\u0343\u0344\7\22\2\2\u0344\u0345\5\u00a6"+
		"T\2\u0345\u0085\3\2\2\2\u0346\u0347\5\u00b8]\2\u0347\u0348\7\24\2\2\u0348"+
		"\u0349\5\u00ba^\2\u0349\u034a\7\25\2\2\u034a\u034b\7N\2\2\u034b\u034c"+
		"\7\26\2\2\u034c\u034d\7\22\2\2\u034d\u034e\5\u00a8U\2\u034e\u0087\3\2"+
		"\2\2\u034f\u0350\7v\2\2\u0350\u0089\3\2\2\2\u0351\u0353\7\u0082\2\2\u0352"+
		"\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u0354\3\2\2\2\u0354\u0355\7{"+
		"\2\2\u0355\u008b\3\2\2\2\u0356\u0357\7{\2\2\u0357\u008d\3\2\2\2\u0358"+
		"\u035a\7*\2\2\u0359\u0358\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u035b\3\2"+
		"\2\2\u035b\u0361\7{\2\2\u035c\u035e\7*\2\2\u035d\u035c\3\2\2\2\u035d\u035e"+
		"\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0361\7|\2\2\u0360\u0359\3\2\2\2\u0360"+
		"\u035d\3\2\2\2\u0361\u008f\3\2\2\2\u0362\u0364\7\u0082\2\2\u0363\u0362"+
		"\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\3\2\2\2\u0365\u036b\7{\2\2\u0366"+
		"\u0368\7\u0082\2\2\u0367\u0366\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u0369"+
		"\3\2\2\2\u0369\u036b\7|\2\2\u036a\u0363\3\2\2\2\u036a\u0367\3\2\2\2\u036b"+
		"\u0091\3\2\2\2\u036c\u036d\7\24\2\2\u036d\u036e\5\u0088E\2\u036e\u036f"+
		"\7\25\2\2\u036f\u0370\5\u0088E\2\u0370\u0371\7\26\2\2\u0371\u0093\3\2"+
		"\2\2\u0372\u0373\7\24\2\2\u0373\u0374\5\u0088E\2\u0374\u0375\7\25\2\2"+
		"\u0375\u0376\5\u0088E\2\u0376\u0377\7\25\2\2\u0377\u0378\5\u0088E\2\u0378"+
		"\u0379\7\26\2\2\u0379\u0095\3\2\2\2\u037a\u037b\7\24\2\2\u037b\u037c\5"+
		"\u0088E\2\u037c\u037d\7\25\2\2\u037d\u037e\5\u0088E\2\u037e\u037f\7\25"+
		"\2\2\u037f\u0380\5\u0088E\2\u0380\u0381\7\25\2\2\u0381\u0382\5\u0088E"+
		"\2\u0382\u0383\7\26\2\2\u0383\u0097\3\2\2\2\u0384\u0385\7\24\2\2\u0385"+
		"\u0386\5\u008aF\2\u0386\u0387\7\25\2\2\u0387\u0388\5\u008aF\2\u0388\u0389"+
		"\7\26\2\2\u0389\u0099\3\2\2\2\u038a\u038b\7\24\2\2\u038b\u038c\5\u008a"+
		"F\2\u038c\u038d\7\25\2\2\u038d\u038e\5\u008aF\2\u038e\u038f\7\25\2\2\u038f"+
		"\u0390\5\u008aF\2\u0390\u0391\7\26\2\2\u0391\u009b\3\2\2\2\u0392\u0393"+
		"\7\24\2\2\u0393\u0394\5\u008aF\2\u0394\u0395\7\25\2\2\u0395\u0396\5\u008a"+
		"F\2\u0396\u0397\7\25\2\2\u0397\u0398\5\u008aF\2\u0398\u0399\7\25\2\2\u0399"+
		"\u039a\5\u008aF\2\u039a\u039b\7\26\2\2\u039b\u009d\3\2\2\2\u039c\u039d"+
		"\7\24\2\2\u039d\u039e\5\u008cG\2\u039e\u039f\7\25\2\2\u039f\u03a0\5\u008c"+
		"G\2\u03a0\u03a1\7\26\2\2\u03a1\u009f\3\2\2\2\u03a2\u03a3\7\24\2\2\u03a3"+
		"\u03a4\5\u008cG\2\u03a4\u03a5\7\25\2\2\u03a5\u03a6\5\u008cG\2\u03a6\u03a7"+
		"\7\25\2\2\u03a7\u03a8\5\u008cG\2\u03a8\u03a9\7\26\2\2\u03a9\u00a1\3\2"+
		"\2\2\u03aa\u03ab\7\24\2\2\u03ab\u03ac\5\u008cG\2\u03ac\u03ad\7\25\2\2"+
		"\u03ad\u03ae\5\u008cG\2\u03ae\u03af\7\25\2\2\u03af\u03b0\5\u008cG\2\u03b0"+
		"\u03b1\7\25\2\2\u03b1\u03b2\5\u008cG\2\u03b2\u03b3\7\26\2\2\u03b3\u00a3"+
		"\3\2\2\2\u03b4\u03b5\7\24\2\2\u03b5\u03b6\5\u008eH\2\u03b6\u03b7\7\25"+
		"\2\2\u03b7\u03b8\5\u008eH\2\u03b8\u03b9\7\26\2\2\u03b9\u00a5\3\2\2\2\u03ba"+
		"\u03bb\7\24\2\2\u03bb\u03bc\5\u008eH\2\u03bc\u03bd\7\25\2\2\u03bd\u03be"+
		"\5\u008eH\2\u03be\u03bf\7\25\2\2\u03bf\u03c0\5\u008eH\2\u03c0\u03c1\7"+
		"\26\2\2\u03c1\u00a7\3\2\2\2\u03c2\u03c3\7\24\2\2\u03c3\u03c4\5\u008eH"+
		"\2\u03c4\u03c5\7\25\2\2\u03c5\u03c6\5\u008eH\2\u03c6\u03c7\7\25\2\2\u03c7"+
		"\u03c8\5\u008eH\2\u03c8\u03c9\7\25\2\2\u03c9\u03ca\5\u008eH\2\u03ca\u03cb"+
		"\7\26\2\2\u03cb\u00a9\3\2\2\2\u03cc\u03cd\7\24\2\2\u03cd\u03ce\5\u0090"+
		"I\2\u03ce\u03cf\7\25\2\2\u03cf\u03d0\5\u0090I\2\u03d0\u03d1\7\26\2\2\u03d1"+
		"\u00ab\3\2\2\2\u03d2\u03d3\7\24\2\2\u03d3\u03d4\5\u0090I\2\u03d4\u03d5"+
		"\7\25\2\2\u03d5\u03d6\5\u0090I\2\u03d6\u03d7\7\25\2\2\u03d7\u03d8\5\u0090"+
		"I\2\u03d8\u03d9\7\26\2\2\u03d9\u00ad\3\2\2\2\u03da\u03db\7\24\2\2\u03db"+
		"\u03dc\5\u0090I\2\u03dc\u03dd\7\25\2\2\u03dd\u03de\5\u0090I\2\u03de\u03df"+
		"\7\25\2\2\u03df\u03e0\5\u0090I\2\u03e0\u03e1\7\25\2\2\u03e1\u03e2\5\u0090"+
		"I\2\u03e2\u03e3\7\26\2\2\u03e3\u00af\3\2\2\2\u03e4\u03e7\5\u00b2Z\2\u03e5"+
		"\u03e7\7t\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e5\3\2\2\2\u03e7\u00b1\3\2"+
		"\2\2\u03e8\u03e9\t\7\2\2\u03e9\u00b3\3\2\2\2\u03ea\u03ed\5\u00b6\\\2\u03eb"+
		"\u03ed\7t\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed\u00b5\3\2"+
		"\2\2\u03ee\u03ef\t\b\2\2\u03ef\u00b7\3\2\2\2\u03f0\u03f1\7\u0083\2\2\u03f1"+
		"\u00b9\3\2\2\2\u03f2\u03f3\7t\2\2\u03f3\u00bb\3\2\2\2\u03f4\u03f5\7R\2"+
		"\2\u03f5\u03f7\7\4\2\2\u03f6\u03f8\5\u00be`\2\u03f7\u03f6\3\2\2\2\u03f8"+
		"\u03f9\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2\2\2\u03fa\u03fb\3\2"+
		"\2\2\u03fb\u03fc\7\5\2\2\u03fc\u00bd\3\2\2\2\u03fd\u0402\7y\2\2\u03fe"+
		"\u03ff\7\60\2\2\u03ff\u0400\5\u00c6d\2\u0400\u0401\7\61\2\2\u0401\u0403"+
		"\3\2\2\2\u0402\u03fe\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0404\3\2\2\2\u0404"+
		"\u0405\7\22\2\2\u0405\u0406\5\u00c0a\2\u0406\u00bf\3\2\2\2\u0407\u040f"+
		"\5\u00c2b\2\u0408\u0409\7\24\2\2\u0409\u040a\5\u00c2b\2\u040a\u040b\7"+
		"\25\2\2\u040b\u040c\5\u00c4c\2\u040c\u040d\7\26\2\2\u040d\u040f\3\2\2"+
		"\2\u040e\u0407\3\2\2\2\u040e\u0408\3\2\2\2\u040f\u00c1\3\2\2\2\u0410\u0411"+
		"\7{\2\2\u0411\u00c3\3\2\2\2\u0412\u0413\7{\2\2\u0413\u00c5\3\2\2\2\u0414"+
		"\u0415\7{\2\2\u0415\u00c7\3\2\2\2\u0416\u0417\7\u0083\2\2\u0417\u00c9"+
		"\3\2\2\2\u0418\u0419\7\u0083\2\2\u0419\u00cb\3\2\2\2\u041a\u041e\5\u00ce"+
		"h\2\u041b\u041e\5\n\6\2\u041c\u041e\5\u0106\u0084\2\u041d\u041a\3\2\2"+
		"\2\u041d\u041b\3\2\2\2\u041d\u041c\3\2\2\2\u041e\u00cd\3\2\2\2\u041f\u0428"+
		"\5\u00d0i\2\u0420\u0428\5\u00d2j\2\u0421\u0428\5\u00d4k\2\u0422\u0428"+
		"\5\u00d6l\2\u0423\u0428\5\u00d8m\2\u0424\u0428\5\u00e8u\2\u0425\u0428"+
		"\5\u00eex\2\u0426\u0428\5\u00f2z\2\u0427\u041f\3\2\2\2\u0427\u0420\3\2"+
		"\2\2\u0427\u0421\3\2\2\2\u0427\u0422\3\2\2\2\u0427\u0423\3\2\2\2\u0427"+
		"\u0424\3\2\2\2\u0427\u0425\3\2\2\2\u0427\u0426\3\2\2\2\u0428\u00cf\3\2"+
		"\2\2\u0429\u042a\7S\2\2\u042a\u042b\7w\2\2\u042b\u00d1\3\2\2\2\u042c\u042d"+
		"\7T\2\2\u042d\u042e\7x\2\2\u042e\u00d3\3\2\2\2\u042f\u0430\7U\2\2\u0430"+
		"\u0431\7u\2\2\u0431\u00d5\3\2\2\2\u0432\u0433\7V\2\2\u0433\u00d7\3\2\2"+
		"\2\u0434\u0439\7\n\2\2\u0435\u0436\7\60\2\2\u0436\u0437\5\u00dco\2\u0437"+
		"\u0438\7\61\2\2\u0438\u043a\3\2\2\2\u0439\u0435\3\2\2\2\u0439\u043a\3"+
		"\2\2\2\u043a\u043c\3\2\2\2\u043b\u043d\5\u00dan\2\u043c\u043b\3\2\2\2"+
		"\u043c\u043d\3\2\2\2\u043d\u00d9\3\2\2\2\u043e\u043f\7\24\2\2\u043f\u0440"+
		"\5\u00dep\2\u0440\u0441\7\25\2\2\u0441\u0442\5\u00e0q\2\u0442\u0443\7"+
		"\26\2\2\u0443\u044f\3\2\2\2\u0444\u0445\7\24\2\2\u0445\u0446\5\u00dep"+
		"\2\u0446\u0447\7\25\2\2\u0447\u0448\5\u00e0q\2\u0448\u0449\7\25\2\2\u0449"+
		"\u044a\5\u00e2r\2\u044a\u044b\7\25\2\2\u044b\u044c\5\u00e4s\2\u044c\u044d"+
		"\7\26\2\2\u044d\u044f\3\2\2\2\u044e\u043e\3\2\2\2\u044e\u0444\3\2\2\2"+
		"\u044f\u00db\3\2\2\2\u0450\u0451\7{\2\2\u0451\u00dd\3\2\2\2\u0452\u0453"+
		"\5\u00e6t\2\u0453\u00df\3\2\2\2\u0454\u0455\5\u00e6t\2\u0455\u00e1\3\2"+
		"\2\2\u0456\u0457\7r\2\2\u0457\u00e3\3\2\2\2\u0458\u0459\7r\2\2\u0459\u00e5"+
		"\3\2\2\2\u045a\u045b\t\t\2\2\u045b\u00e7\3\2\2\2\u045c\u0461\7[\2\2\u045d"+
		"\u045e\7\60\2\2\u045e\u045f\5\u00dco\2\u045f\u0460\7\61\2\2\u0460\u0462"+
		"\3\2\2\2\u0461\u045d\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\3\2\2\2\u0463"+
		"\u0472\5\u00eav\2\u0464\u0469\7[\2\2\u0465\u0466\7\60\2\2\u0466\u0467"+
		"\5\u00dco\2\u0467\u0468\7\61\2\2\u0468\u046a\3\2\2\2\u0469\u0465\3\2\2"+
		"\2\u0469\u046a\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c\7\24\2\2\u046c"+
		"\u046d\5\u00eav\2\u046d\u046e\7\25\2\2\u046e\u046f\5\u00ecw\2\u046f\u0470"+
		"\7\26\2\2\u0470\u0472\3\2\2\2\u0471\u045c\3\2\2\2\u0471\u0464\3\2\2\2"+
		"\u0472\u00e9\3\2\2\2\u0473\u0474\7s\2\2\u0474\u00eb\3\2\2\2\u0475\u0476"+
		"\7s\2\2\u0476\u00ed\3\2\2\2\u0477\u047c\7\\\2\2\u0478\u0479\7\60\2\2\u0479"+
		"\u047a\5\u00dco\2\u047a\u047b\7\61\2\2\u047b\u047d\3\2\2\2\u047c\u0478"+
		"\3\2\2\2\u047c\u047d\3\2\2\2\u047d\u047e\3\2\2\2\u047e\u047f\5\u00f0y"+
		"\2\u047f\u00ef\3\2\2\2\u0480\u0481\t\n\2\2\u0481\u00f1\3\2\2\2\u0482\u0483"+
		"\7]\2\2\u0483\u0485\7\4\2\2\u0484\u0486\5\u00f4{\2\u0485\u0484\3\2\2\2"+
		"\u0486\u0487\3\2\2\2\u0487\u0485\3\2\2\2\u0487\u0488\3\2\2\2\u0488\u0489"+
		"\3\2\2\2\u0489\u048a\7\5\2\2\u048a\u00f3\3\2\2\2\u048b\u0493\5\u00f6|"+
		"\2\u048c\u0493\5\u00f8}\2\u048d\u0493\5\u00fa~\2\u048e\u0493\5\u00fc\177"+
		"\2\u048f\u0493\5\u00fe\u0080\2\u0490\u0493\5\u0100\u0081\2\u0491\u0493"+
		"\5\u0102\u0082\2\u0492\u048b\3\2\2\2\u0492\u048c\3\2\2\2\u0492\u048d\3"+
		"\2\2\2\u0492\u048e\3\2\2\2\u0492\u048f\3\2\2\2\u0492\u0490\3\2\2\2\u0492"+
		"\u0491\3\2\2\2\u0493\u00f5\3\2\2\2\u0494\u0495\7^\2\2\u0495\u0496\7{\2"+
		"\2\u0496\u00f7\3\2\2\2\u0497\u0498\7_\2\2\u0498\u0499\7{\2\2\u0499\u00f9"+
		"\3\2\2\2\u049a\u049b\7`\2\2\u049b\u049c\7{\2\2\u049c\u00fb\3\2\2\2\u049d"+
		"\u049e\7a\2\2\u049e\u049f\7u\2\2\u049f\u00fd\3\2\2\2\u04a0\u04a1\7\r\2"+
		"\2\u04a1\u04a2\5\u0104\u0083\2\u04a2\u00ff\3\2\2\2\u04a3\u04a4\7b\2\2"+
		"\u04a4\u04a5\5\u0104\u0083\2\u04a5\u0101\3\2\2\2\u04a6\u04a7\7c\2\2\u04a7"+
		"\u04a8\5\u0104\u0083\2\u04a8\u0103\3\2\2\2\u04a9\u04aa\t\13\2\2\u04aa"+
		"\u0105\3\2\2\2\u04ab\u04ac\7l\2\2\u04ac\u04ad\5\u0108\u0085\2\u04ad\u0107"+
		"\3\2\2\2\u04ae\u04b5\5\u010a\u0086\2\u04af\u04b5\7{\2\2\u04b0\u04b1\5"+
		"\u010a\u0086\2\u04b1\u04b2\7\u0082\2\2\u04b2\u04b3\7{\2\2\u04b3\u04b5"+
		"\3\2\2\2\u04b4\u04ae\3\2\2\2\u04b4\u04af\3\2\2\2\u04b4\u04b0\3\2\2\2\u04b5"+
		"\u0109\3\2\2\2\u04b6\u04b7\t\f\2\2\u04b7\u010b\3\2\2\2=\u0112\u011c\u0123"+
		"\u012d\u0136\u014a\u0150\u015a\u015c\u0167\u016c\u0175\u0184\u0187\u018c"+
		"\u0192\u019b\u01a7\u01ad\u01bb\u01c7\u01d6\u01e1\u01ea\u01ed\u01f9\u0202"+
		"\u020f\u021b\u022c\u0233\u023e\u0249\u025b\u0275\u0352\u0359\u035d\u0360"+
		"\u0363\u0367\u036a\u03e6\u03ec\u03f9\u0402\u040e\u041d\u0427\u0439\u043c"+
		"\u044e\u0461\u0469\u0471\u047c\u0487\u0492\u04b4";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}